-2 
class Guitars
{
private:
    int serialNumber{0};
    float price{0.0};
    // GuitarSpecs spec{};

public:
    Guitars(int serNum, float price)
    {
        this->serialNumber = serNum;
        this->price = price;
    };
    Guitars(const Guitars &s)
        : serialNumber{s.serialNumber}, price{s.price}
    {
        std::cout << "Copy" << std::endl;
    };

    Guitars(Guitars &&source) noexcept : serialNumber{source.serialNumber}, price{source.price}
    {
        source.serialNumber = NULL;
        source.price = NULL;
        std::cout << "Move" << std::endl;
    };

    int GetSerial() const { return serialNumber; };
    float GetPrice() const { return price; };
    void SetPrice(float x) { this->price = x; }
};

class Inventory
{
private:
    list<Guitars *> *guitarList;

public:
    Inventory()
    {
        guitarList = new list<Guitars *>;
    }

    void AddGuitar(int serNum, float price)
    {
        Guitars *x = new Guitars(serNum, price);
        // Guitars x(serNum,price);
        guitarList->push_back(x);
    }

    void Display()
    {
        for (auto &&i : *guitarList)
        {
            std::cout << i->GetPrice() << "   " << i->GetSerial() << endl;
        }
    }

    ~Inventory()
    {
        for (auto &&i : *guitarList)
        {
            std::cout << i->GetSerial() << "  "
                      << "deleted " << std::endl;
            delete i;
        }
        std::cout << "List is deleted" << std::endl;
        delete guitarList;
    }
};

int main()
{
    Inventory I;
    I.AddGuitar(12050, 50.23);
    I.AddGuitar(10000, 20.00);
    I.Display();

    return 0;
}

有人可以向我解释为什么上面的代码中没有调用复制构造函数吗？

当我在堆上创建 Guitar 指针列表以及堆上的 Guitar 对象以及指向它们的指针并将这些指针保存在 Inventory 列表中时，不会调用复制构造函数。为什么会发生这种情况，这是否更有效，因为程序不是要创建对象的副本，它在堆上创建一次，我们将指针保存在我们身边。

4

1 回答 1

2

基于您谈论优化的一些详细答案：

您有以下代码：

list<Guitars *> *guitarList;

void AddGuitar(int serNum, float price)
{
    Guitars *x = new Guitars(serNum, price);
    // Guitars x(serNum,price);
    guitarList->push_back(x);
}

我认为您使用所有这些指针的原因是为了更快。如果一个Guitars对象像往常一样在堆栈上创建然后被推回，那将创建一个副本，true。
您可以做的是定义一个移动操作Guitars并将堆栈对象移动到您在列表中创建的内容中，例如通过调用移动构造函数。
但更好的是使用std::list::emplace_back，如下所示：

list<Guitars> guitarList;

void AddGuitar(int serNum, float price)
{
    guitarList.emplace_back(serNum, price);
}

无论如何，如果您谈论最优性，那些指针并不好。指针需要额外的空间，并且每次访问数据时，都必须取消引用指针。此外，正如@PaulMcKenzie 在评论中所写，这可能会阻止编译器为您优化。

此外，使列表成员本身成为一个指针，与list<Guitars*>* guitarList;or一起使用list<Guitars>* guitarList;，也不是一个好主意。我看到的唯一原因是如果您想交换两个Inventory对象的列表，但在这种情况下，只需调用std::swap列表即可。

如果您放弃指针，请注意您的所有其他代码如何立即变得容易得多。你甚至根本不需要定义你的析构函数。

（至于你问的实际问题，就像@Jarod42 已经写的那样，复制指针不会复制对象。）

（顺便说一句，如果这个类Guitars代表一把吉他，那么我会选择单数，Guitar.）

编辑：

我用不同的方式创建了一个小系列的测试来填充列表，Guitars大部分没有修改。（我删除了非指针的分配NULL。）无论如何，我做了以下测试设置：

#include <iostream>
#include <list>

class Guitar
{
private:
    int serialNumber{0};
    float price{0.0};

public:
    Guitar(int serNum, float price)
    {
        std::cout << "Base" << std::endl;
        this->serialNumber = serNum;
        this->price = price;
    }
    Guitar(const Guitar& s)
        : serialNumber{s.serialNumber}, price{s.price}
    {
        std::cout << "Copy" << std::endl;
    }

    Guitar(Guitar&& source) noexcept : serialNumber{source.serialNumber}, price{source.price}
    {
        std::cout << "Move" << std::endl;
    }
};

void test_1()
{        
    std::cout << "test 1" << std::endl;
    std::list<Guitar*> guitarList;
    Guitar* x = new Guitar(1, 2.);
    guitarList.push_back(x);
    std::cout << std::endl;
}

void test_2()
{ 
    std::cout << "test 2" << std::endl;
    std::list<Guitar> guitarList;
    Guitar x(1, 2.);
    guitarList.push_back(x);
    std::cout << std::endl;
}

void test_3()
{ 
    std::cout << "test 3" << std::endl;
    std::list<Guitar> guitarList;
    guitarList.push_back(Guitar(1, 2.));
    std::cout << std::endl;
}

void test_4()
{
    std::cout << "test 4" << std::endl;
    std::list<Guitar> guitarList;
    guitarList.emplace_back(1, 2.);
    std::cout << std::endl;
}

int main()
{
    test_1();
    test_2();
    test_3();
    test_4();
}

这个的输出是：

test 1
Base

test 2
Base
Copy

test 3
Base
Move

test 4
Base

我希望这可以进一步了解这里的工作原理。
这些测试可以在http://www.cpp.sh/35ld6下找到

另外，我想提一下，如果我们谈论优化，我们必须谈论我们优化的内容。现在，我们有一些几乎没有内容的小对象列表。在这种情况下，根本不会优化，因为我们谈论的是纳秒的差异。
需要考虑的案例有：

  1. 一小部分易于移动的大物体。在这种情况下，我们需要确保没有调用复制构造函数，但 move 就可以了。
  2. 一小部分难以移动的大物体。在这种情况下，我们只想使用基本运算符，可能像您最初所做的那样通过指针 - 但emplace_back也可以工作并使事情变得更容易。请注意，难以移动的对象会暗示该类的设计不佳。
  3. 一大堆小物件。在这里，我们希望使用尽可能少的构造函数，包括移动构造函数。我们也不想使用指针列表，因为这会给我们每个对象额外的 64 位，以及稍后的大量取消引用。在那种情况下，emplace_back真的会发光。

所以换句话说，你不会出错emplace_back。

于 2020-11-15T09:56:28.857 回答