4

我最近在使用 c++ 代码时遇到了一个非常奇怪的问题。我在极简主义的例子中重现了这个案例。我们有一个 Egg 类：

class Egg
{
private:
    const char* name;
public:
    Egg() {};
    Egg(const char* name) {
        this->name=name;
    }
    const char* getName() {
        return name;
    }
};

我们还有一个篮子类来装鸡蛋

const int size = 15;
class Basket
{
private:
    int currentSize=0;
    Egg* eggs;
public:
    Basket(){
        eggs=new Egg[size];
    }
    void addEgg(Egg e){
        eggs[currentSize]=e;
        currentSize++;
    }
    void printEggs(){
        for(int i=0; i<currentSize; i++)
        {
            cout<<eggs[i].getName()<<endl;
        }
    }
    ~Basket(){
        delete[] eggs;
    }
};

所以这是一个按预期工作的例子。

 Basket basket;
 Egg egg1("Egg1");
 Egg egg2("Egg2");

 basket.addEgg(egg1);
 basket.addEgg(egg2);
 basket.printEggs();
 //Output: Egg1 Egg2

这是预期的结果，但是如果我想根据某个循环变量添加 N 个生成名称的鸡蛋，我会遇到以下问题。

 Basket basket;
 for(int i = 0; i<2; i++) {
    ostringstream os;
    os<<"Egg"<<i;
    Egg egg(os.str().c_str());
    basket.addEgg(egg);
 }
 basket.printEggs();
 //Output: Egg1 Egg1

如果我将循环条件更改为 i<5，我会得到“Egg4 Egg4 Egg4 Egg4 Egg4”。它将最后添加的 Egg 保存在动态 Egg 数组的所有索引中。

在谷歌搜索后，我发现给 Egg 中的 char* 名称变量一个固定大小并strcpy在构造函数中使用可以解决这个问题。

这是“固定”的 Egg 类。

class Egg
{
private:
     char name[50];
public:
    Egg(){};
    Egg(const char* name)
    {
        strcpy(this->name, name);
    }
    const char* getName()
    {
        return name;
    }
};

现在的问题是为什么？

提前致谢。

这是整个代码的链接。

4

4 回答 4

5

让我们仔细看看这个表达式： os.str().c_str().

该函数按值str返回一个字符串，并以这种方式使用它使返回的字符串成为一个临时对象，其生命周期仅到表达式结束。一旦表达式结束，字符串对象就被破坏并且不再存在。

您传递给构造函数的指针是指向临时字符串对象的内部字符串的指针。一旦字符串对象被破坏，该指针就不再有效，使用它会导致未定义的行为。

简单的解决方案当然是std::string在您想使用字符串时使用。更复杂的解决方案是使用数组并在字符串消失之前复制字符串的内容（就像您在“固定”Egg类中所做的那样）。但请注意，使用固定大小数组的“固定”解决方案容易出现缓冲区溢出。

于 2016-04-20T09:25:41.840 回答
2

在第一种情况下，您复制指向字符串的指针。

在第二种情况下，strcpy()您实际上是对字符串进行深度复制。

好的，我不冗长，让我澄清一下。在第一种情况下，您复制指针，该指针指向使用创建的字符串ostringstream。当超出范围时会发生什么？

未定义的行为！

于 2016-04-20T09:18:18.433 回答
1

os.str()是一个匿名临时类型，并且一旦该匿名临时超出范围（在语句末尾发生），std::string访问指向的内存的行为是未定义的。您的第二种情况有效，因为在临时超出范围之前获取指向的数据的副本。但是代码仍然很脆弱：固定大小的字符缓冲区很容易被溢出。（一个简单的解决方法是使用）。.c_str()strcpy(this->name, name);.c_str()strncpy

但要正确修复，请利用 C++ 标准库：std::string用作 的类型name，const std::string&用作 的返回类型getName，以及用于将鸡蛋放在篮子中的容器。std::list<Egg>

于 2016-04-20T09:27:53.233 回答
0

您不会在Egg构造函数中复制字符串，只是一个指针，即字符串的起始地址。

碰巧的是，您的 ostrings 的所有实例一次又一次地在同一个地方分配它们的缓冲区。碰巧缓冲区没有在构造for循环和输出打印for循环之间被覆盖。

这就是为什么最终你所有的Eggs 都有它们的name指针指向同一个地方，并且那个地方包含构建的姓氏。

于 2016-04-20T09:41:06.230 回答