C++ 如何在不使用分配的情况下访问类中的私有变量？

我试图更好地理解内存分配/指针等

正如您在“test”方法中看到的，我试图访问

CTest类的名称

，以便将其填充到我的

计划数组中

。是否有可能在没有分配的情况下访问CTest类

（CTest*Test=new CTest（）；）

。我的意思是，是否可以在这里仅使用指针来访问

CTest

的变量

Name

这是我的节目：

class CTest
{
    public:
    void setName(std::string str){ Name = str;}
    std::string getName(){return Name;}

    private:
    std::string Name;
};

class CEvent
{
public:
    CEvent() = default;
    void setTestName(std::string str){Test->setName(str);}
    std::string getTestName(){return Test->getName();}
     ~CEvent(){};
private:
    std::string Name;
    CTest *Test = new CTest();   //Here
};

class CBlock
{
public:
    CBlock() = default;
    friend class CBooking;
    ~CBlock(){}

private:
    CEvent *Schedule[7][5];
};

class CBooking
{
public:
    CBooking() = default;
    void test();
    ~CBooking(){}

private:
    CBlock *Sched;
};

void CBooking::test()
{ 
   Sched = new CBlock();
   Sched->Schedule[3][2] = new CEvent();

   std::string a = "test2";
   Sched->Schedule[3][2]->setTestName(a);

   std::cout << Sched->Schedule[3][2]->getTestName();
}

int main()
{
    CBooking a;
    a.test();
    return 0;
}

class-CTest
{
公众：
void setName（std:：string str）{Name=str；}
std:：string getName（）{return Name；}
私人：
std：：字符串名；
};
C类事件
{
公众：
CEvent（）=默认值；
void setTestName（std:：string str）{Test->setName（str）；}
std:：string getTestName（）{return Test->getName（）；}
~CEvent（）{}；
私人：
std：：字符串名；
CTest*Test=new CTest（）；//此处
};
类CBlock
{
公众：
CBlock（）=默认值；
朋友类图书；
~CBlock（）{}
私人：
CEvent*附表[7][5]；
};
课堂预习
{
公众：
CBooking（）=默认值；
无效试验（）；
~CBooking（）{}
私人：
CBlock*Sched；
};
void CBooking:：test（）
{ 
Sched=新的CBlock（）；
Sched->Schedule[3][2]=新的CEvent（）；
std:：string a=“test2”；
Sched->Schedule[3][2]->setTestName（a）；
std:：cout Schedule[3][2]->getTestName（）；
}
int main（）
{
C预订a；
a、 test（）；
返回0；
}

如果要为

CEvent

提供一个现有的

CTest

对象，则将其作为引用传递给构造函数：

class CEvent
{
public:
    CEvent(CTest &test): test(test) {}

    void setTestName(std::string str){test.setName(str);}
    std::string getTestName(){return test.getName();}
private:
    CTest &test;
};

...

CTest test;
CEvent event(test);
event.setTestName("test");
std::cout << event.getTestName() << "\n";

class-CEvent
{
公众：
CEvent（测试与测试）：测试（测试）{}
void setTestName（std:：string str）{test.setName（str）；}
std:：string getTestName（）{return test.getName（）；}
私人：
测试与测试；
};
...
CTest试验；
CEvent事件（测试）；
事件。setTestName（“测试”）；
std:：cout如果您不想要
新建
，请不要使用
新建
。只需声明一个
CTest
。你能澄清这个问题吗？什么是强制动态分配？我没有看到。对于
CTest
，只需将
CTest*Test=…
更改为
CTest-Test和
Test->
到
Test。
我从我的真实程序中提取了这个。关于附表->附表[3][2]=新的CEvent（）；我实际上试图用CEvent的不同变量填充这个数组，在我的程序中，我有5个私有变量，我在数组中填充了它们。问题是我使用了大量内存，我想以某种方式改变想法。我不知道你所说的“没有分配”是什么意思
Name
是
CTest
的非静态数据成员，这意味着您需要一个
CTest
对象来保存名称。这可以通过
CTest*test=new CTest（）完成或
CTest测试，但在这两种情况下，都是为该对象分配内存。除非你的意思是给你的
CEvent
对象一个指向现有
CTest
对象的指针？@Kevin我就是这个意思。对不起，我解释得不好。我想给CEvent对象（Schedule）一个指向现有CTest对象的指针。这意味着，当我需要将CTest的私有变量分配给CEvent schedule时，我不需要每次都分配内存。感谢您的快速解决方案，但有一个问题：如果CTest是一个抽象类呢？因为如果我将CTest设置为一个抽象类，我会遇到以下错误：
error:无法将变量“test”声明为抽象类型“CTest”
CTest测试
^~~~
output.cpp:6:7:注意：因为以下虚拟函数在“CTest”中是纯函数：类CTest
output.cpp:10:13:注意：virtual int CTest:：print（）'virtual print（）=0Oops，忽略我之前的评论。我想你说过如果
CEvent
是抽象的：）你只需要创建一个从
CTest
派生的类的具体对象，并将其传递给
CEvent
对象的构造函数即可。e、 g.
衍生测试；CEvent事件（测试）。哦，好的，再次感谢