标签: forward-declaration

我正在寻找一本好书，参考材料，涉及类的前向声明，特别是。当源位于多个目录中时，例如。dirA 中的 A 类在 dirB 中的 B 类中向前声明？这是怎么做到的？

另外，有任何有关模板问题、高级用途和实例化问题的材料吗？

谢谢。

在C++中,执行从main()的顶部开始.好的,我知道了.现在看看这个:

  #include <iostream>
   int main ()
   {
       int x;
       std::cin >> x;
       std::cout << add (x, x);
       return 0;
   }

   int add(int x, int y)
   {
         return x+y;
   }

编译器在执行此程序时抛出错误.如果我将add()移到main()上面或使用前向声明,程序将被编译而没有任何错误.这是否意味着编译器不能从调用函数跳转到查找调用者下面定义的被调用函数的定义.请原谅我的英语.

我很困惑是否使用 extern 来向前声明 C 中的函数。情况是每个函数都位于单独的 .c/.cpp 文件中。我通过这个问题-External links of const in C了解到，如果所有都是 .c 文件，我不应该使用 extern 进行前向声明，无论该函数是否在同一文件中定义。

但我想更多地了解何时显式使用 extern 进行前向声明（我认为当前向声明的函数是用与调用函数不同的语言定义时，需要 extern），以及需要注意的任何警告。

我正在尝试创建一个类原型,但是我不断收到错误:'aClass'使用未定义的类'myClass'

我很确定我正在制作原型.使用原型函数可以工作,但是类原型没有.

extern class myClass;               // prototypes
extern void myFunction();

int main()                          // main
{
    myClass aClass;
    myFunction();
    return 0;
}

class myClass {                     // this doesn't work
public:
    void doSomething() {
        return;
    }

    myClass() {};
};
void myFunction() {                 // this works
    return;
}

我有以下代码，有一个由“Eyebrow”类组成的“Face”类。面部表情可以更改为允许的公共枚举之一，从而控制应如何更改每个组成部分。每个组成类都应该负责响应更改后的表达式，这就是我想将其传递给每个组成部分的原因。

脸.h：

#include "eyebrow.h"
class Face {
    public:
        enum Expression {NEUTRAL, JOY, ANGER};
        void setExpression(Expression);
    private:
         Eyebrow left_eyebrow;
}

脸.cpp：

#include "face.h"
#include "eyebrow.h"

void Face::setExpression(Expression e) {
     left_eyebrow.setExpression(e);
}

眉毛.h：

#include "face.h"

class Eyebrow {
    public:
         void setExpression(Face::Expression);
};

代码正在用 Cmake 编译：

add_executable(Main main.cpp face.cpp eyebrow.cpp)

我收到以下编译器错误：'Face' 尚未在 eye.h 中的 void setExpression(Face::Expression_e) 中声明。

然后我转发声明的人脸（见下文）并得到编译器错误：'Face::Expression' has not been created in void setExpression(Face::Expression); 在眉毛.h

眉毛.h（带有前向声明）：

#include "face.h"

class Face;
class Eyebrow {
    public:
         void setExpression(Face::Expression);
};

有什么推荐的解决方法，朋友们应该用吗？

Let's say I have a piece of code like this:

// Foo.h:
class Incomplete; // the forward-declaration
class Foo {
  void bar(Incomplete&); // doesn't really matter
};

// Foo.cpp:
class Incomplete : private Baz {
};
void Foo::bar(Incomplete&) {
}

Is forward-declaring classes like in Foo.h standard-compliant? If it is, since which language version? What about the same for protected inheritance?

在input()我调用的 中Table()，我收到一个错误，指出该函数未声明：

#include <iostream>

using namespace std;

void input(){
   Table();
}

void Table(){
   input();
}

int main(){
   input();
   Table();
}

我们可以转发声明一个函数：

void func1();

void func2() {
    // use func1
}

void func1() {
    // do stuff
}

func1如果调用以下命令，这可能是必要的func2：

void func1();

void func2() {
    func1();
}

void func1() {
    if (condition) {
        func2();
    }
}

虽然func1第二个示例中的内联并不困难，但我不知道在任意复杂的程序中是否存在此类编译器优化的理论障碍。在第二种情况下，前向声明是必要的，并且可能会丢失与程序的递归性质相关的编译器优化。

问题：当不需要但仍然使用前向声明时（例如第一个示例），任何主要编译器（gcc、clang、msvc）上是否会丢失任何编译器优化？

我有三个C++类:Position,Employer和Person.每个人都有雇主和就业岗位.如下所示,我使用前向类声明将Employer和Position类加入Person类.

我是新的转发类的声明,但是发现何时使用前向声明帖子对于何时以及如何使用前向声明非常有见地.

但是,我主要关心如何在我的main函数中使用setPosition()？

person.h

class Position;
class Employer;

class Person
{
public:
    // other public members
    void setPosition(Employer* newC, Position* newP)
    {
        m_position = newP;
        m_employer = newC;
    }
private:
    // other member variables
    Position* m_position;
    Employer* m_employer;
};

以下是main.cpp的片段:

#include "employer.h"
#include "person.h"
#include "position.h"

int main()
{
    Employer StarFleet("StarFleet Federation", "space exploration");
    Person JLP("Jean-Luc Picard");
    Position cpt("StarFleet Captain", "Save the world");

    JLP.setPosition(StarFleet,cpt);

    return 0;
}

问题是得到一个编译错误:

错误:main.cpp候选中对'Person :: setPosition(Employer&,Position&)'的调用没有匹配函数:void Person :: setPosition(Employer*,Position*)

从"雇主"到"雇主*"的参数1没有已知的转换

我想知道如何在main()中使用setPosition？ …

我刚刚意识到当我在C中定义一个函数并使用它时,我可以使用它并稍后定义函数或者定义它并在以后使用它.例如,

int mult (int x, int y)
{
  return x * y;
}

int main()
{
  int x;
  int y;
  scanf( "%d", &x );
  scanf( "%d", &y );
  printf( "The product of your two numbers is %d\n", mult( x, y ) );
}

和

int main()
    {
      int x;
      int y;
      scanf( "%d", &x );
      scanf( "%d", &y );
      printf( "The product of your two numbers is %d\n", mult( x, y ) );
    }   

int mult (int x, int y) …

我正在尝试使用 zmq 创建一个通用节点，该节点将形成动态计算图，但是我在类中的 zmq 套接字的前向声明中遇到错误。我想知道是否有人可以阐明这一点？该类的精简版本是：

节点.hpp

/* \n *  node.hpp\n*/ \n\n#ifndef NODE_\n#define NODE_\n\n#include <iostream>\n#include "zmq.hpp"\n\nclass Node\n{\nprivate:\n    std::string name_;\n    std::ostream& log_;\n    zmq::context_t context_;\n    zmq::socket_t subscriber_;\n    zmq::socket_t publisher_;\n\npublic:\n    Node(std::ostream& log, std::string name);\n    void sendlog(std::string msg);\n};\n\n#endif // NODE_ \n

节点.cpp

/* \n *  node.cpp\n*/ \n\n#include <iostream>\n#include <string>\n#include "zmq.hpp"\n#include "node.hpp"\n\nNode::Node(std::ostream& log, std::string name): \n    log_(log),\n    name_(name)\n{\n    sendlog(std::string("initialising ") + name_);\n\n    zmq::context_t context_(1);\n    zmq::socket_t subscriber_(context_, zmq::socket_type::sub);\n    zmq::socket_t publisher_(context_, zmq::socket_type::pub);\n\n    subscriber_.connect("ipc:///tmp/out.ipc");\n    publisher_.connect("ipc:///tmp/in.ipc");\n\n    sendlog(std::string("finished initialisation"));\n}\n\nvoid Node::sendlog(std::string msg)\n{\n    this->log_ << msg << std::endl;\n}\n

我有一个简单且可重现的代码,看起来像这样:

template <typename T>
class Proxy {
private:
    Wrap<T> &self; // If I comment this, it will work
public:
    Proxy() {}
};

template <typename T>
class Wrap {
    T *p;
public:
    Proxy<T> foo() {
        return Proxy<T>();
    }
};

int main()
{
    return 0;
}

我得到的错误是:

'Wrap'没有命名类型

如果我评论Wrap<T> &self,那么它会起作用,但这不是我需要的.我需要Wrap<T>成为Proxy班上的一员.我怎样才能做到这一点？

因此,经过一些研究,我一直在努力为我的继承类分别设置类头和源代码.以下示例是我的类的缩短版本.我的所有标题都包含警卫,默认构造函数和虚拟析构函数.它们还具有变量所需的getter和setter函数.我将主要只显示变量和包含.

编译器错误位于代码下方的底部

MainProgram类:

MainProgram.h

#include "FileMgr.h"
#include "InfoMgr.h"

class FileMgr;
class InfoMgr;

class MainProgram
{
private:
    FileMgr* fileMgr;
    InfoMgr* infoMgr;
public:
             .
             .
             .
}; // !MainProgram

MainProgram.cpp

#include "MainProgram.h"
#include <iostream>

MgrBase类(基类):

MgrBase.h

#include "MainProgram.h"
#include <string>

class MainProgram;

class MgrBase
{
protected:
    MainProgram* mainProgram;

    MgrBase() : mainProgram(nullptr) {}
    virtual ~MgrBase() {}

public:
    virtual bool Init() = 0;
}; // !MgrBase

FileMgr类:

FileMgr.h

#include "MgrBase.h"

class MainProgram;

class FileMgr : public MgrBase
{
public:
    FileMgr(MainProgram* mainProgram);
        .
        .
        . …