为什么在堆上分配对象时不调用复制构造函数？

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

您有以下代码：

list<Guitars *> *guitarList;

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

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

list<Guitars> guitarList;

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

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

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

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

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

（顺便说一句，如果类代表一把吉他，那么我会选择单数，。GuitarsGuitar

编辑：

我创建了一小系列测试，用不同的方式填充列表，大部分使用未经修改的。（不过，我删除了非指针的分配。无论如何，我做了以下测试设置：GuitarsNULL

#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. 易于移动的大物体的小列表。在这种情况下，我们需要确保没有调用复制构造函数，但移动就可以了。
2. 一小部分难以移动的大物体。在这种情况下，我们只想使用基本运算符，可能像您最初那样使用指针 - 但也有效并使事情变得更容易。请注意，难以移动的对象将暗示该类的设计很糟糕。emplace_back
3. 一大堆小对象。在这里，我们希望使用尽可能少的构造函数，包括 move 构造函数。我们也不想使用指针列表，因为这会为我们提供每个对象额外的 64 位，并且以后会有很多取消引用。在那种情况下，真的很闪耀。emplace_back

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