头文件中的类声明 我已经使用C++数月了，但是我在使用头和源代码文件时遇到了一个错误。我创建了一个源代码文件 包含类枪（示例非实际程序）：

然后在我的主源文件中执行以下操作：

int main()
{
gun *mygun = new gun;
mygun->doStuff();
return 0;
}

但是，当我尝试执行它时，会出现以下错误： 不完整类型“class gun”的使用无效，我认为问题在于我如何在标题中声明它，我是否做错了？我打算怎么做？谢谢

谢谢所有帮助过你的人！我现在明白了，我以为只有远期申报

---

进入头文件，谢谢你的回答

您似乎以错误的方式将实现和头文件分开。转发声明不应出现在头文件中。整个宣言应该是正确的！这就是代码的结构

枪.hpp

#pragma once

class Gun
{
private:
    int stuff;
public:
    void doStuff();
};

#include "Gun.hpp"
#include <iostream>
using std::cout;
using std::endl;

void Gun::doStuff()
{
    cout << stuff << endl;
}

int main()
{
    Gun *mygun = new Gun;
    mygun->doStuff();

    delete mygun; // <-- remember this!
    return 0;
}

Gun.cpp

#pragma once

class Gun
{
private:
    int stuff;
public:
    void doStuff();
};

#include "Gun.hpp"
#include <iostream>
using std::cout;
using std::endl;

void Gun::doStuff()
{
    cout << stuff << endl;
}

int main()
{
    Gun *mygun = new Gun;
    mygun->doStuff();

    delete mygun; // <-- remember this!
    return 0;
}

#包括“Gun.hpp”
#包括
使用std：：cout；
使用std：：endl；
空枪：：多斯塔夫（）
{
cout您似乎以错误的方式将实现和头文件分开。前向声明不应该放在头文件中。整个声明应该放在头文件中！这是您的代码应该如何构造的

枪.hpp

#pragma once

class Gun
{
private:
    int stuff;
public:
    void doStuff();
};

#include "Gun.hpp"
#include <iostream>
using std::cout;
using std::endl;

void Gun::doStuff()
{
    cout << stuff << endl;
}

int main()
{
    Gun *mygun = new Gun;
    mygun->doStuff();

    delete mygun; // <-- remember this!
    return 0;
}

Gun.cpp

#pragma once

class Gun
{
private:
    int stuff;
public:
    void doStuff();
};

#include "Gun.hpp"
#include <iostream>
using std::cout;
using std::endl;

void Gun::doStuff()
{
    cout << stuff << endl;
}

int main()
{
    Gun *mygun = new Gun;
    mygun->doStuff();

    delete mygun; // <-- remember this!
    return 0;
}

#包括“Gun.hpp”
#包括
使用std：：cout；
使用std：：endl；
空枪：：多斯塔夫（）
{
coutgun
类的整个声明需要在头文件中。头文件中声明的是前向声明，它本身不足以创建类的实例。前向声明仅用于允许其他代码声明指针，因为编译器没有声明指针不需要知道全部细节。但是前向声明不能用于创建类的实际对象实例。这就是为什么您会收到关于不完整类型的错误。From
main（）从
的角度来看，它不知道枪实际上是什么样子，所以它无法创建它的完整实例

gun
类方法的实现需要在gun的源文件中，源文件可以
#包括头文件以验证和访问类成员

枪


gun.cpp

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

void gun::doStuff()
{
    std::cout << stuff << std::endl;
}

gun
类的整个声明需要在头文件中。头文件中声明的是前向声明，它本身不足以创建类的实例。前向声明仅用于允许其他代码声明指针，因为编译器不需要d只需声明一个指针就可以了解完整的细节。但是前向声明不能用于创建类的实际对象实例。这就是为什么您会收到关于不完整类型的错误。From
main（）从
的角度来看，它不知道枪实际上是什么样子，所以它无法创建它的完整实例

gun
类方法的实现需要在gun的源文件中，源文件可以
#包括头文件以验证和访问类成员

枪


gun.cpp

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

void gun::doStuff()
{
    std::cout << stuff << std::endl;
}

在
gun.h中

#ifndef GUN_H_
#define GUN_H_
// You can use #pragma once too here
class gun
{
     private:
         int stuff;
     public:
         void doStuff();
};

#endif

在
gun.cpp
文件中

#include "gun.h"

void gun::doStuff()
{
    cout << stuff << endl;
}

您可以使用

g++ -o prg_name gun.cpp main.cpp && ./prg_name

在
gun.h中

#ifndef GUN_H_
#define GUN_H_
// You can use #pragma once too here
class gun
{
     private:
         int stuff;
     public:
         void doStuff();
};

#endif

在
gun.cpp
文件中

#include "gun.h"

void gun::doStuff()
{
    cout << stuff << endl;
}

您可以使用

g++ -o prg_name gun.cpp main.cpp && ./prg_name

Gun:：doStuff（）
应该是
Gun:：doStuff（）
整个类定义-
class Gun{…}；
-进入头文件。仅向前声明不足以满足大多数用途。当你说整个类定义时，你的意思是像class Gun{private:int stuff；public:void doStuff（）；}；因为使用前向声明，您会告诉系统类存在，但没有其他内容。您必须至少有类定义。在链接时会检查实现。少量更正。类的声明是
class gun；
，在这里它是无用的。类的定义是
class gun{…}；
（其中包括
doStuff
）的声明，它属于头文件（例如
gun.h
）。
doStuff
的定义是
void gun:：doStuff（）{…}
，它属于源文件（例如
gun.cc
）。
gun:：doStuff（）
应该是
gun:：doStuff（）
整个类定义-
类gun{…}；
-进入头文件。仅向前声明不足以用于大多数用途。当你说整个类定义时，你指的是类gun{private:int stuff；public:void doStuff（）；}；因为使用前向声明，您会告诉系统类存在，但没有其他内容。您必须至少有类定义。在链接时会检查实现。少量更正。类的声明是
class gun；
，在这里它是无用的。类的定义是
class gun{…}；
（其中包括
doStuff
）的声明，它属于头文件（例如
gun.h
）。
doStuff
的定义是
void gun:：doStuff（）{…}
，它属于源文件（例如
gun.cc
）.形式上，您在标题中输入的是类的定义，在源文件中输入的是每个成员函数的定义。形式上，您在标题中输入的是类的定义，在源文件中输入的是每个成员函数的定义。