C++ 类方法调用变量方法

我目前的情况是这样一种结构：

class Foo {
    public:
        void call() {
            b.call();
        }
    private:
        Bar b;
};

class Bar {
    public:
        void call() {
            std::cout << "Hello there" << std::endl;
        }
};

int main() {
    Foo f;

    f.call(); // This calls directly the b.call() function
}

---

您所说的是语言级别的委托构造。有些语言有内置的支持，但是C++没有。你必须像以前那样用“艰难的方式”去做

---

如果这是一个非常普遍的问题，您可以定义一个宏，但通常最好使用难看的代码，而不是混淆或误导的代码。

您所说的是语言级别的委托构造。有些语言有内置的支持，但是C++没有。你必须像以前那样用“艰难的方式”去做

---

如果这是一个非常普遍的问题，您可以定义一个宏，但通常最好使用难看的代码，而不是混淆或误导的代码。

通常没有必要像这样尝试和帮助编译器。编译器非常擅长优化这类事情。您不需要告诉编译器

Foo:：call

实际上只是一个

Bar:：call

。编译器会找到答案的。考虑一个稍微调整的例子：

extern void DisplayMessage(char const*);

class Bar {
public:
  void call() {
    DisplayMessage("Hello there");
  }
};

class Foo {
public:
  void call() {
    b.call();
  }
private:
  Bar b;
};

int main() {
  Foo f;

  f.call(); // This calls directly the b.call() function
}

当我使用Clang 7.0和-O3编译此文件时，我得到以下结果：

main:                                   # @main
    push    rax
    mov     edi, offset .L.str
    call    DisplayMessage(char const*)
    xor     eax, eax
    pop     rcx
    ret

---

请注意，编译器已经完全删除了对象，只留下了对

DisplayMessage

函数的直接调用。

通常不需要像这样尝试和帮助编译器。编译器非常擅长优化这类事情。您不需要告诉编译器

Foo:：call

实际上只是一个

Bar:：call

。编译器会找到答案的。考虑一个稍微调整的例子：

extern void DisplayMessage(char const*);

class Bar {
public:
  void call() {
    DisplayMessage("Hello there");
  }
};

class Foo {
public:
  void call() {
    b.call();
  }
private:
  Bar b;
};

int main() {
  Foo f;

  f.call(); // This calls directly the b.call() function
}

当我使用Clang 7.0和-O3编译此文件时，我得到以下结果：

main:                                   # @main
    push    rax
    mov     edi, offset .L.str
    call    DisplayMessage(char const*)
    xor     eax, eax
    pop     rcx
    ret

---

请注意，编译器已经完全删除了对象，只留下了对

DisplayMessage

函数的直接调用。

您可能会有较短的代码：

class Bar {
public:
    void call() const {
        std::cout << "Hello there" << std::endl;
    }
};

class Foo : private Bar // private is superfluous here, as we use class instead of struct
{
public:
    using Bar::call;
};

类栏{
公众：
void call（）常量{
std:：cout您的代码可能较短：

class Bar {
public:
    void call() const {
        std::cout << "Hello there" << std::endl;
    }
};

class Foo : private Bar // private is superfluous here, as we use class instead of struct
{
public:
    using Bar::call;
};

类栏{
公众：
void call（）常量{
std：：cout Nope.你所拥有的是你所需要的方式（忽略一个事实，
Bar
需要在
Foo
之前定义，它才能真正编译）
b
private
不是有原因吗？@CinCout选择性地连接到
b
上的某些方法是一种相当常见的模式。无关：据我所知，
Bar b；
从未做过Lauren
b.call（）；
doll.Nope。你拥有的是你需要的方式（忽略
Bar
需要在
Foo
之前定义才能真正编译）不是
b
private
有原因吗？@CinCout在
b
上有选择地连接到某些方法是一种相当常见的模式。无关：据我所知
Bar b；
从来没有做过劳伦
b.call（）
doll.我太懒了，想知道它是否已经存在，但我想我会继续正确地编码…这样懒绝对没有什么错。据你所知，C++17正好加入了这个功能。你这样做的方式。class Foo{public:void call（）->b.call private:Bar b；}；等等，这行得通吗？不，我是说你做这件事的方式很长。区别是零个字符，
{}
vs.
->
，所以我不知道这里有什么大惊小怪的地方。我太懒了，想知道它是否已经存在，但我想我会继续正确地编码……这样的懒绝对没有什么错。据你所知，C++17正好加入了这个功能。你这样做的方式。class Foo{public:void call（）->b.call private:Bar b；}；等等，这行得通吗？不，我是说你做这件事的方式很长。区别是零个字符，
{}
vs.
->
，所以我不知道这里有什么大惊小怪的地方。我实际上并不认为OP的问题是关于优化的，而是根据定义，
Foo:：call
公开了（否则是私有的）
Foo:：b.call
。这种语义的语言构造并不是不合理的。（碰巧它不存在）。是的。考虑到他接受了这样一个答案，我似乎误解了。我并不认为OP的问题是关于优化的，而是根据定义
Foo:：call
公开了（否则是私有的）
Foo：：b.call
。想象这种语义的语言结构并不是一件不合理的事情。（当然，碰巧它不存在）。是的。考虑到他接受了一个大致相同的答案，我似乎误解了。）