在 c++ 中从 char* 获取奇怪的返回值

Getting weird return value from char* in c++

本文关键字：返回值 获取 c++ 中从 char      更新时间：2023-10-16

我是 c++ 编程的新手，我从我设置的 char* 变量中返回了一个奇怪的值，具体取决于我如何使用它。 我显然在做一些非常愚蠢的事情，但我看不到问题所在。 接下来的几段描述了设置(很糟糕(，但只看输出和代码可能更容易。

基本上，我有几个类 - 菜单和菜单项。类的名称类型为 char*。 根据我使用菜单项的方式，当我在菜单项上执行 getName(( 时，我得到奇怪的结果。

我有一个具有状态(测试状态(的机器类。 此测试状态创建一个包含菜单项的菜单。 当我在我的主函数中创建一个 TestState 并让它打印出菜单时，我得到了我期望的。 当我创建一个包含 TestState 的机器并要求它打印菜单时，它会为菜单中根项的名称打印一些奇怪的内容。

输出 - 最后一行我期待菜单项 1，但我得到 Hâ∆Hã=ò

Output direct from TestState Object
Displaying menu state 
menuItem1
root not null 
menuItem1

Output from TestState within Machine
Displaying menu state 
menuItem1
root not null 
Hâ∆Hã=ò

这是我的代码 -主.cpp

#include "Menu.h"
#include "Machine.h"
#include <iostream>
using namespace std;
Machine m;
TestState t;
int main(void) {
    cout << "Output direct from TestState Object" << endl << endl;
    t = TestState();
    t.print();

    cout << endl << endl << "Output from TestState within Machine" << endl << endl;
    m = Machine();
    m.printCurrentState();
}

菜单.h

#ifndef Menu_h
#define Menu_h
#include <stdlib.h>
class MenuItem {
public:
    MenuItem();
    MenuItem(const char* itemName);
    const char* getName() const ;
protected:
    MenuItem *next;
    const char* name;
};
class Menu {
public:
    Menu(MenuItem *rootItem);
    Menu();
    void setRoot(MenuItem *r);
    MenuItem* getRoot() ;
protected:
    MenuItem *root;
};
#endif

机器.h

#ifndef MACHINE_H_
#define MACHINE_H_
#include "Menu.h"
class TestState;
class Machine;
class TestState {
public:
    TestState();
    virtual ~TestState();
    void print();
protected:
    Machine* machine;
    MenuItem menuItem1;
    Menu menuMain;
};
class Machine {
public:
    Machine();
    void printCurrentState();
protected:
    TestState testState;
};
#endif /* MACHINE_H_ */

机器.cpp

#include "Machine.h"
#include <iostream>
using namespace std;
TestState::TestState() {
    menuItem1 = MenuItem("menuItem1");
    menuMain = Menu(&menuItem1);
}
void TestState::print(){
    cout << "Displaying menu state " << endl;
    cout << menuItem1.getName() << endl;
    if (menuMain.getRoot() == NULL) {
        cout << "root is null" << endl;
    } else {
        cout << "root not null " << endl;
        cout << menuMain.getRoot()->getName() << endl;
    }
}
TestState::~TestState() {
    // TODO Auto-generated destructor stub
}
Machine::Machine() {
    testState = TestState();
}
void Machine::printCurrentState() {
    testState.print();
}

任何帮助将不胜感激。 我有点迷茫。谢谢戴夫

我怀疑正在发生的事情是Menu.root指向某处的临时对象。 您会注意到您在主函数中制作了机器的副本：

// in main():
m = Machine(); // makes a machine, then copies it

该机器有一个TestState，它有一个MainMenu，它有一个指向MenuItem的指针：

// in MenuItem class definition:
MenuItem *root;

该指针初始化为原始计算机成员的地址。 问题是，该对象只存在很短的时间：当复制完成时，它被销毁，留下一个悬而未决的指针。

换句话说，您需要确保在复制包含指针的对象时，更新这些指针以反映复制对象的地址，而不是旧对象的地址。

您需要添加如下所示的复制构造函数：

Machine::Machine(const Machine& other)
{
    teststate = other.teststate;
    teststate.machine = this; // you will need to expose TestState.machine to Machine
}
TestState::TestState(const TestState& other)
{
    machine = other.machine; // Machine copy constructor modifies this for us
    menuItem1 = other.menuItem1; // these 3 we have to do
    menuItem2 = other.menuItem2;
    menuMain = other.menuMain;
    menuMain.setRoot(&menuItem1); // update pointers to be to persistent copies
    menuItem1.setNext(&menuItem2);
    menuItem2.setNext(NULL);
}

您可能会注意到您的系统相当脆弱。 我建议少依赖对象之间的指针，因为龙就是这条路。

TestState::TestState() {
    menuItem1 = MenuItem("menuItem1");
    menuItem2 = MenuItem("menuItem2");
    menuMain = Menu(&menuItem1);
    menuMain.add(&menuItem2);
}
Machine::Machine() {
    testState = TestState();
}

构造Machine构造函数构造一个临时TestState并将其数据成员复制到Machine::testState 中。当Machine构造函数完成后，临时TestState消失，但Machine::testState.menuMain.root仍指向临时构造函数的成员。

如何解决：

了解初始化变量的各种方法的含义，以及如何在构造函数中使用初始化列表。

与其写Thing name = Thing(ctorParams);不如将名称作为指针并使用new Thing(ctorParams);。看起来您认为您正在使用指针，但它在没有 new 关键字的情况下工作，因此您继续不使用它们，这会导致您出现错误。

Machine没有

复制构造函数，因此Machine中的各种指针和引用(特别是TestState内(都指向垃圾。

相关文章：