C++ 继承类的指针问题

在下面的代码中，SecClass从FirstClass继承“item”。然而，当我在main中运行'ClassC'时，第一项和第二项都是210。如果我从继承的类（FirstClass）中删除指针，它将按应有的方式运行。我在指针和继承方面仍然很不稳定，所以这里缺少了一些东西

// declaration of FirstClass
// FirstClass.h

#include <iostream>

#ifndef FIRSTCLASS_H
#define FIRSTCLASS_H

using namespace std;

class FirstClass
{
 private:
   int *item;

 public:
   FirstClass();
   FirstClass(int thatItem);
   ~FirstClass();

   int getItem();
   void setItem(int thatItem);

};

#endif


// the implementation of FirstClass.h
// FirstClass.cpp

#include "FirstClass.h"

using namespace std;

FirstClass::FirstClass()
{

int *setInitial = new int;
*setInitial = 5;
item = setInitial;
}

FirstClass::FirstClass(int thatItem)
{
item = &thatItem;
}

FirstClass::~FirstClass(){}

int FirstClass::getItem()
{
    return *item;
}

void FirstClass::setItem(int thatItem) 
{
    item = &thatItem;
}


// declaration of SecClass
// SecClass.h

#ifndef SECCLASS_H
#define SECCLASS_H

#include "FirstClass.h"

using namespace std;

class SecClass : public FirstClass
{
 private:
   int *secItem;

 public:
   SecClass();
   SecClass(int newItem, int thatItem);
   ~SecClass();

   int getSecItem();
   void setSecItem(int newItem);

};

#endif


// the implementation of SecClass.h
// SecClass.cpp

#include "SecClass.h"

using namespace std;

SecClass::SecClass()
{

int *setSecInitial = new int;
*setSecInitial = 16;
secItem = setSecInitial;
}

SecClass::SecClass(int newItem, int thatItem) : FirstClass(thatItem)
{
    secItem = &newItem;
}

SecClass::~SecClass(){}

int SecClass::getSecItem()
{
    return *secItem;
}

void SecClass::setSecItem(int newItem) 
{
    secItem = &newItem;
}


// main program
#include <iostream>
#include "FirstClass.h"
#include "SecClass.h"

using namespace std;

int main()
{

FirstClass classA;
cout << "classA item: " << classA.getItem() << endl << endl;

FirstClass classZ(86);
cout << "classZ item: " << classZ.getItem() << endl << endl;

SecClass classB;
cout << "classB first item: " << classB.getItem() << endl;
cout << "classB second item: " << classB.getSecItem() << endl << endl;

SecClass classC(72, 210);
cout << "classC first item: " << classC.getItem() << endl;
cout << "classC second item: " << classC.getSecItem() << endl;


return 0;
}

//第一类的声明
//头等舱
#包括
#ifndef一等舱
#定义第一类
使用名称空间std；
头等舱
{
私人：
国际*项目；
公众：
第一类（）；
头等舱（该项目）；
~FirstClass（）；
int getItem（）；
无效设置项（int该项）；
};
#恩迪夫
//FirstClass.h的实现
//头等舱
#包括“头等舱.h”
使用名称空间std；
FirstClass:：FirstClass（）
{
int*setInitial=新int；
*setInitial=5；
项目=设置初始值；
}
FirstClass:：FirstClass（int that item）
{
item=&thatItem；
}
FirstClass:：~FirstClass（）{}
int FirstClass:：getItem（）
{
退货*项目；
}
void FirstClass:：setItem（int thatItem）
{
item=&thatItem；
}
//二等舱声明
//SecClass.h
#ifndef SECCLASS_H
#定义SECCLASS_H
#包括“头等舱.h”
使用名称空间std；
二等舱：公共一等舱
{
私人：
国际*secItem；
公众：
SecClass（）；
SecClass（int newItem，int thatItem）；
~SecClass（）；
int getSecItem（）；
无效设置项（int newItem）；
};
#恩迪夫
//SecClass.h的实现
//SecClass.cpp
#包括“SecClass.h”
使用名称空间std；
SecClass:：SecClass（）
{
int*SETSECINITAL=新int；
*设置初始值=16；
secItem=setSecInitial；
}
SecClass:：SecClass（int newItem，int thatItem）：第一类（thatItem）
{
secItem=&newItem；
}
SecClass:：~SecClass（）{}
int SecClass:：getSecItem（）
{
返回*第二项；
}
void SecClass:：setSecItem（int newItem）
{
secItem=&newItem；
}
//主程序
#包括
#包括“头等舱.h”
#包括“SecClass.h”
使用名称空间std；
int main（）
{
一等甲级；
不能你的构造函数

void FirstClass::setItem(int thatItem) 
{
    item = &thatItem;
}

正在做一件非常糟糕的事情，那就是存储临时对象的地址（传递给构造函数的
int
）

从构造函数返回后，
int
将立即被销毁，并且您的
项
指针将指向一个已被重新用于其他内容的内存区域

当你做这种事情（包括）时，任何事情都可能发生，所以不要那样做。
你的构造函数

void FirstClass::setItem(int thatItem) 
{
    item = &thatItem;
}

正在做一件非常糟糕的事情，那就是存储临时对象的地址（传递给构造函数的
int
）

从构造函数返回后，
int
将立即被销毁，并且您的
项
指针将指向一个已被重新用于其他内容的内存区域

当你做这类事情（包括）时，任何事情都可能发生，所以不要这样做。
这里是使用指针的修改代码。它是有效的。正如你提到的，它只是
学习指针等

    class FirstClass
{
 private:
   int *item;

 public:
   FirstClass();
   FirstClass(int *thatItem);
   ~FirstClass();

   int getItem();
};

FirstClass::FirstClass()
{
item = new int(5);
}

FirstClass::FirstClass(int *thatItem)
{
item = thatItem;
}

FirstClass::~FirstClass(){}

int FirstClass::getItem()
{
    return *item;
}

class SecClass : public FirstClass
{
    private:
    int *secItem;

    public:
    SecClass();
    SecClass(int *newItem, int *thatItem);
    ~SecClass();

    int getSecItem();
};

SecClass::SecClass()
{
secItem = new int(16);
}

SecClass::SecClass(int *newItem, int *thatItem) : FirstClass(thatItem)
{
    secItem = newItem;
}

SecClass::~SecClass(){}

int SecClass::getSecItem()
{
    return *secItem;
}

int main()
{

FirstClass classA;
cout << "classA item: " << classA.getItem() << endl << endl;

int *i = new int(86);
FirstClass classZ(i);
cout << "classZ item: " << classZ.getItem() << endl << endl;

SecClass classB;
cout << "classB first item: " << classB.getItem() << endl;
cout << "classB second item: " << classB.getSecItem() << endl << endl;

int *j = new int(72);
int *k = new int(210);
SecClass classC(j,k);
cout << "classC first item: " << classC.getItem() << endl;
cout << "classC second item: " << classC.getSecItem() << endl;


return 0;
}

class头等舱
{
私人：
国际*项目；
公众：
第一类（）；
头等舱（整数*该项目）；
~FirstClass（）；
int getItem（）；
};
FirstClass:：FirstClass（）
{
项目=新整数（5）；
}
FirstClass:：FirstClass（int*thatItem）
{
项目=该项目；
}
FirstClass:：~FirstClass（）{}
int FirstClass:：getItem（）
{
退货*项目；
}
二等舱：公共一等舱
{
私人：
国际*secItem；
公众：
SecClass（）；
SecClass（int*新项，int*该项）；
~SecClass（）；
int getSecItem（）；
};
SecClass:：SecClass（）
{
第二项=新整数（16）；
}
SecClass:：SecClass（int*newItem，int*thatItem）：第一类（thatItem）
{
secItem=newItem；
}
SecClass:：~SecClass（）{}
int SecClass:：getSecItem（）
{
返回*第二项；
}
int main（）
{
一等甲级；
cout这是使用指针的修改代码。它是有效的。正如您所提到的，它只是
学习指针等

    class FirstClass
{
 private:
   int *item;

 public:
   FirstClass();
   FirstClass(int *thatItem);
   ~FirstClass();

   int getItem();
};

FirstClass::FirstClass()
{
item = new int(5);
}

FirstClass::FirstClass(int *thatItem)
{
item = thatItem;
}

FirstClass::~FirstClass(){}

int FirstClass::getItem()
{
    return *item;
}

class SecClass : public FirstClass
{
    private:
    int *secItem;

    public:
    SecClass();
    SecClass(int *newItem, int *thatItem);
    ~SecClass();

    int getSecItem();
};

SecClass::SecClass()
{
secItem = new int(16);
}

SecClass::SecClass(int *newItem, int *thatItem) : FirstClass(thatItem)
{
    secItem = newItem;
}

SecClass::~SecClass(){}

int SecClass::getSecItem()
{
    return *secItem;
}

int main()
{

FirstClass classA;
cout << "classA item: " << classA.getItem() << endl << endl;

int *i = new int(86);
FirstClass classZ(i);
cout << "classZ item: " << classZ.getItem() << endl << endl;

SecClass classB;
cout << "classB first item: " << classB.getItem() << endl;
cout << "classB second item: " << classB.getSecItem() << endl << endl;

int *j = new int(72);
int *k = new int(210);
SecClass classC(j,k);
cout << "classC first item: " << classC.getItem() << endl;
cout << "classC second item: " << classC.getSecItem() << endl;


return 0;
}

class头等舱
{
私人：
国际*项目；
公众：
第一类（）；
头等舱（整数*该项目）；
~FirstClass（）；
int getItem（）；
};
FirstClass:：FirstClass（）
{
项目=新整数（5）；
}
FirstClass:：FirstClass（int*thatItem）
{
项目=该项目；
}
FirstClass:：~FirstClass（）{}
int FirstClass:：getItem（）
{
退货*项目；
}
二等舱：公共一等舱
{
私人：
国际*secItem；
公众：
SecClass（）；
SecClass（int*新项，int*该项）；
~SecClass（）；
int getSecItem（）；
};
SecClass:：SecClass（）
{
第二项=新整数（16）；
}
SecClass:：SecClass（int*newItem，int*thatItem）：第一类（thatItem）
{
secItem=newItem；
}
SecClass:：~SecClass（）{}
int SecClass:：getSecItem（）
{
返回*第二项；
}
int main（）
{
一等甲级；
我可以先取消引用吗？如果我做了*item=&thatItem，这会给我造成一个错误。@huitlacoche:你需要像在没有参数的其他构造函数中那样为
item
分配空间，然后才复制值。好的，我知道了。因为我仍然不确定如何最好地使用指针，我想最好尽可能多地使用它们但是，如果我将所有类数据成员保留在堆栈上，并创建指向类对象的指针（例如，FirstClass*classA=new FirstClass），这不是实现了相同的基本思想吗？如果我在FirstClass.h中使用（int*item=new int；），我会得到一个与[warning]类似的警告非静态数据成员初始值设定项仅适用于-std=c++11或-std=gnu++11[默认启用]你知道这是什么吗？@ HutiLoCoCH：在C++中，03个成员的初始化器只能在构造函数中指定。如果你不理解非静态成员和静态成员之间的区别，那么你应该真正地停止使用C++编译器来代替自己，而不是读一本好的C++书籍（例如一个）。C++是可以的，但是，不管你有多聪明，实际上是用实验来学习的错误语言（实际上你是聪明的，而且更糟糕的是因为逻辑并不总是有帮助）。我应该先去引用吗？如果我做*项= &