Question

一个愚蠢的问题。我有一个oo :: class，做了一件糟糕的事情-包括procs到构造函数和方法中：

oo::class create MyClass {

    constructor {args} {
        proc silly {args} {
            puts "-------------silly's args: $args"
            puts namespace=[namespace current]
            set v [namespace current]::sillyvar
            puts $v=[incr $v]
            puts vars=[info vars [namespace current]::*]
        }
    }
    destructor {
        foreach proc {silly SILLY} {
            rename $proc ""
        }
    }
    method createprocs {} {
        proc SILLY {args} {
            puts "-------------SILLY's args: $args"
            set v [namespace current]::sillyvar
            puts $v=[incr $v]
        }
    }
    method another {} {
        silly ;# works ok
    }
}
MyClass create myobj
myobj createprocs
[info object namespace myobj]::silly hello world
myobj another
[info object namespace myobj]::SILLY HELLO WORLD
MyClass destroy

输出看起来正常：

-------------silly's args: hello world
namespace=::oo::Obj12
::oo::Obj12::sillyvar=1
vars=::oo::Obj12::sillyvar
-------------silly's args: 
namespace=::oo::Obj12
::oo::Obj12::sillyvar=2
vars=::oo::Obj12::sillyvar
-------------SILLY's args: HELLO WORLD
::oo::Obj12::sillyvar=3

您能不能说好吗？如果是这样，在哪里有用？

我现在看到的是：

1）傻和傻都是“出口”。

2）我不需要“我的傻”和“ [自]傻”就可以从某个对象访问该傻过程。

Answer 1

您能不能说好吗？

对我来说似乎还可以，只是您不需要析构函数。这些过程是在对象实例的命名空间（也是对象的变量，FWIW）中创建的，并且在销毁对象时也会自动删除这些过程（反之亦然）；如果没有这些，您将无法拥有这些过程。另一个）。

如果可以，在哪里有用？

我使用一些在方法和构造函数内部创建的过程（和其他命令）。他们可以做类似Tcl的私有子语言之类的事情（就像您可以将命令放在普通名称空间中一样；这没有什么大不一样），所以这确实非常有用。使用forward ed方法也很容易委托它们。

较容易的技巧之一是在外部对象内部创建子对象，并通过以下方式委派一些方法调用：

oo::class create Outer {
    constructor {} {
        Inner create inner [self]
        puts "created [self]"
    }
    destructor {
        puts "destroyed [self]"
    }
    method foo {} {
        puts "this is foo of [self]"
    }
    forward bar  inner foo
}
oo::class create Inner {
    constructor {outer} {
        puts "created [self] inside $outer"
    }
    destructor {
        puts "destroyed [self]"
    }
    method foo {} {
        puts "this is foo of [self]"
    }
}

演示：

Outer create x
# ⇒ created ::oo::Obj13::inner inside ::x
# ⇒ created ::x
x foo
# ⇒ this is foo of ::x
x bar
# ⇒ this is foo of ::oo::Obj13::inner
x destroy
# ⇒ destroyed ::x
# ⇒ destroyed ::oo::Obj13::inner

这显示了工作中的遏制和委派（它基于您的过程将使用的相同机制）。如您所见，inner是在x的私有命名空间中创建的，并且x bar被路由到inner foo。更好的是，x被销毁时，inner也完全没有特殊代码。在复杂的代码中非常有用。

Tcl oo :: class中的proc

1 个答案: