Question

我对the documentation of isSomeFunction以及以下代码感到困惑：

static assert(!isFunctionPointer!(typeof(Object.toString)));  // makes sense
static assert(!isDelegate!(typeof(Object.toString)));         // what??
static assert( isSomeFunction!(typeof(Object.toString)));     // what??

有人可以向我解释“功能”和“功能指针”之间的区别吗？

Answer 1

简答：

is(T == function) T是否为函数
isFunctionPointer!T T是否为函数指针（不是委托者）
isDelegate!T T是否为代表
isSomeFunction!T T是一个函数，一个函数指针，或一个委托

长答案：

一个功能就是一个功能。

auto func(int val) {...}

这是一段带有名称的代码，您可以使用该名称调用该名称。你给它参数，它做它做的任何事情，它返回一个结果。你可以打电话给它，但你无法传递它。你需要一个函数指针。

函数指针是指向函数的指针。就像int是int而int*是指向int的指针一样，而int 不是指针int，函数不是函数指针。如果需要函数指针，则需要指向函数的指针。语法与int的语法不同，但它的概念相同。

委托是一个带状态的函数指针。例如，在

中

int foo(int value)
{
    int bar()
    {
        return value + 5;
    }

    auto barDel = &bar;

    return barDel();
}

void main()
{
    auto fooFunc = &foo;
}

foo是一个函数，bar是一个嵌套函数，可以访问其外部作用域，而barDel是一个委托，因为它是一个带状态的函数指针（外部状态） bar有权访问）。如果你将barDel传递给另一个函数（或返回它），你将获得一个闭包（除非它传递的函数通过scope获取委托，在这种情况下该函数保证委托将不要逃避它的范围），因为该状态需要放在堆上，以便它继续存在，即使它的状态来自的函数调用在被调用时已经完成。另一方面，funcFoo是一个函数指针，因为foo没有任何外部状态。如果bar为static，那么barDel也将是一个函数指针而不是委托，因为bar将无法再访问它所在的函数（尽管它然后必须更改正文，因为它将无法再访问value）。

现在，就你的例子而言。 Object.toString是Object的成员函数。所以，这是一个功能。它具有与之关联的 no 状态。功能永远不会。它目前的签名是

string toString();

但是因为它是Object的成员函数，所以它的签名实际上就像

string toString(Object this);

this作为参数传递给toString。它不是与toString相关联的州。因此，&Object.toString不是代表。它只是一个函数指针。并且Object.toString不是函数指针，因此即使&Object.toString 是委托，static assert(isDelegate!(typeof(Object.toString)))仍然会失败，因为为了成为委托，它必须是一个函数指针，它不是。这是一个功能。

现在，不幸的是，typeof(&Object.toString)被认为是string function()而不是string function(Object)，因此使用它来调用toString并使用实际的Object需要一点点工作的。它可以完成，但我不记得此刻（并且它有点丑陋的IIRC）。但它不会是一个代表，因为没有与之相关的州。

如果你想要一个可以传递Object并让它调用成员函数的函数，那么你可以做类似的事情

auto obj = getObjectFromSomewhere();
auto func = function(Object obj){return obj.toString();};
auto result = func(obj);

如果要将对象与成员函数关联，并且能够在该对象上调用该成员函数而不必传递该对象，那么只需将其包装在委托中：

auto obj = getObjectFromSomewhere();
auto del = delegate(){return obj.toString();};
auto result = del();

这段代码应该总结一下并很好地说明事情：

int foo(int value)
{
    int bar()
    {
        return value + 5;
    }

    static assert( is(typeof(bar) == function));
    static assert(!isFunctionPointer!(typeof(bar)));
    static assert(!isDelegate!(typeof(bar)));
    static assert( isSomeFunction!(typeof(bar)));

    auto barDel = &bar;
    static assert(!is(typeof(barDel) == function));
    static assert(!isFunctionPointer!(typeof(barDel)));
    static assert( isDelegate!(typeof(barDel)));
    static assert( isSomeFunction!(typeof(barDel)));

    static int boz(int i)
    {
        return i + 2;
    }

    static assert( is(typeof(boz) == function));
    static assert(!isFunctionPointer!(typeof(boz)));
    static assert(!isDelegate!(typeof(boz)));
    static assert(isSomeFunction!(typeof(boz)));

    auto bozFunc = &boz;
    static assert(!is(typeof(bozFunc) == function));
    static assert( isFunctionPointer!(typeof(bozFunc)));
    static assert(!isDelegate!(typeof(bozFunc)));
    static assert( isSomeFunction!(typeof(bozFunc)));

    return boz(bar());
}

static assert( is(typeof(foo) == function));
static assert(!isFunctionPointer!(typeof(foo)));
static assert(!isDelegate!(typeof(foo)));
static assert( isSomeFunction!(typeof(foo)));

void main()
{
    auto fooFunc = &foo;
    static assert(!is(typeof(fooFunc) == function));
    static assert( isFunctionPointer!(typeof(fooFunc)));
    static assert(!isDelegate!(typeof(fooFunc)));
    static assert( isSomeFunction!(typeof(fooFunc)));
}

static assert( is(typeof(Object.toString) == function));
static assert(!isFunctionPointer!(typeof(Object.toString)));
static assert(!isDelegate!(typeof(Object.toString)));
static assert( isSomeFunction!(typeof(Object.toString)));

static assert(!is(typeof(&Object.toString) == function));
static assert( isFunctionPointer!(typeof(&Object.toString)));
static assert(!isDelegate!(typeof(&Object.toString)));
static assert( isSomeFunction!(typeof(&Object.toString)));

isSomeFunction对于所有这些都是true，因为它们都是函数，函数指针没有状态或委托。

foo，bar，boz和Object.toString都是函数，因此它们true is(T == function)但不是fooFunc其他

bozFunc，&Object.toString和true是没有状态的函数指针，因此isFunctionPointer!T为barDel但是true不是为了其他人。

isDelegate!T是代理人，因此{{1}}为{{1}}，而其他人则不是。{/ p>
希望这能为你解决问题。

“功能”与“功能指针” - 有什么区别？

1 个答案:

简答：

长答案：