C++ 类中的类：'；不是类型'；错误

这是我正在尝试的一个简化版本

#include <iostream>
using namespace std ;

class a
    {
    public:
    a(int xinit, int yinit){x=xinit; y=yinit;}

    private:
    int x, y;
    };

class b
    {
    public:
    b(int pinit, int qinit){p=pinit; q=qinit;}

    private:
    int p,q;
    a Test(p,q);
    };

int main()
    {
    return 0;
    }

#包括
使用名称空间std；
甲级
{
公众：
a（int-xinit，int-yinit）{x=xinit；y=yinit；}
私人：
int x，y；
};
b类
{
公众：
b（intpinit，intqinit）{p=pinit；q=qinit；}
私人：
int p，q；
a检验（p，q）；
};
int main（）
{
返回0；
}

---

编译时，它会给出错误“p”不是类型。谁能告诉我出了什么问题吗？

您没有为函数的参数声明数据类型

Test

a Test(p,q);

一定是这样的:

a Test(int p, int q);

---

您没有为函数

Test

a Test(p,q);

一定是这样的:

a Test(int p, int q);

按这条线

a Test(p,q)

返回类型

a

并接受类型

p

和

q

的（匿名）参数。 您可能想使用：

a Test(int p, int q);

如果要将其声明为类属性，则必须为类a创建非参数构造函数：

a() {}

并在构造函数中初始化

测试

：

b(int pinit, int qinit)
{
    p=pinit;
    q=qinit;
    Test=a(p,q);
}

或者更确切地说，使用：

按这条线

a Test(p,q)

返回类型

a

并接受类型

p

和

q

的（匿名）参数。 您可能想使用：

a Test(int p, int q);

如果要将其声明为类属性，则必须为类a创建非参数构造函数：

a() {}

并在构造函数中初始化

测试

：

b(int pinit, int qinit)
{
    p=pinit;
    q=qinit;
    Test=a(p,q);
}

或者更确切地说，使用：

<代码>测试（p，q）被解析为函数声明。您不希望这样（我假设）-相反，您希望将成员声明为

测试并在构造函数中分配它

因此，您可以做的是显式初始化它：

public:
b(int pinit, int qinit): p(pinit), q(qinit), Test(p, q) { }

<代码>测试（p，q）被解析为函数声明。您不希望这样（我假设）-相反，您希望将成员声明为
测试并在构造函数中分配它

因此，您可以做的是显式初始化它：

public:
b(int pinit, int qinit): p(pinit), q(qinit), Test(p, q) { }

您可以这样编写代码

#include <iostream>
using namespace std;

class a
{
public:
    a(int xinit, int yinit){x=xinit; y=yinit;}

private:
    int x, y;
};

class b
{
public:
    b(int pinit, int qinit):p(pinit), q(qinit), Test(p, q){}

private:
    int p,q;
    a Test;
};

int main()
{
    return 0;
}

#包括
使用名称空间std；
甲级
{
公众：
a（int-xinit，int-yinit）{x=xinit；y=yinit；}
私人：
int x，y；
};
b类
{
公众：
b（intpinit，intqinit）：p（pinit），q（qinit），Test（p，q）{}
私人：
int p，q；
测试；
};
int main（）
{
返回0；
}
您可以这样编写代码

#include <iostream>
using namespace std;

class a
{
public:
    a(int xinit, int yinit){x=xinit; y=yinit;}

private:
    int x, y;
};

class b
{
public:
    b(int pinit, int qinit):p(pinit), q(qinit), Test(p, q){}

private:
    int p,q;
    a Test;
};

int main()
{
    return 0;
}

#包括
使用名称空间std；
甲级
{
公众：
a（int-xinit，int-yinit）{x=xinit；y=yinit；}
私人：
int x，y；
};
b类
{
公众：
b（intpinit，intqinit）：p（pinit），q（qinit），Test（p，q）{}
私人：
int p，q；
测试；
};
int main（）
{
返回0；
}
或者（在C++11或更高版本中）在声明中用大括号初始化它：
测试{p，q}很好，从来都不知道你可以在函数中定义函数。@aisbaa:你不能。但是您可以在类中声明函数。@aisbaa您不能在函数中定义函数。您可以在类中声明成员函数。@aisbaa顺便说一句，您的命名约定过于混乱。在我意识到
a
是类型，
Test
是成员变量的名称之前，我几乎无法调试这个该死的初始值设定项列表。它真的应该是一个测试…或者（在C++11或更高版本中）在声明中用大括号初始化它：
a Test{p，q}很好，从来都不知道你可以在函数中定义函数。@aisbaa:你不能。但是您可以在类中声明函数。@aisbaa您不能在函数中定义函数。您可以在类中声明成员函数。@aisbaa顺便说一句，您的命名约定过于混乱。在我意识到
a
是类型，
Test
是成员变量的名称之前，我几乎无法调试这个该死的初始值设定项列表。它真的应该是一个测试
…荒谬的
Test=a（p，q）
仍然存在于第一个ctor示例中。这似乎可行，但我不明白为什么。我是否在初始化没有参数的类a的实例，然后将其更改为具有参数的实例？第一个ctor示例中仍然存在荒谬的
Test=a（p，q）
。这似乎可行，但我不明白为什么。我是否在初始化没有参数的类a的实例，然后将其更改为具有参数的实例？