总结

我最近看到了一些关于 std::vector 的问题，出于好奇，我一直在研究它们。我从来没有真正使用过 STL，但我知道你可以使用 vector 来处理对象数组的分配，而且我可以发誓有一种方法可以使用默认构造函数在 vector 是创建。的确，这个问题Initializing a std::vector with default constructor处理使用复制构造函数和默认值与仅使用默认构造函数初始化 vector 。

但是，由于我一直在 Visual Studio 2010 中使用 C++ 控制台应用程序项目进行一些试验，因此我没有得到与此解释一致的结果。根据对上述问题 ( given here ) 的回答中的评论之一，如果您使用，例如 std::vector<FooClass> FooArray = new std::vector<FooClass>(20);它应该使用默认构造函数，这确实是我预期的行为。

然而，我编写了一些跟踪代码来跟踪对象的创建，假设它们将使用默认构造函数创建，并且似乎每个对象都刚刚创建并随后立即销毁。最后，在到处搜索之后，我继续实现了一个复制构造函数，它也可以打印出信息。我看到的是，如果我初始化 FooClass 的 vector 使用默认值，例如 new std::vector<FooClass>(20, FooClass()) ，然后我得到预期的结果:FooClass()被实例化时， vector 中的每个项目都使用复制构造函数初始化为该对象的拷贝，然后用作默认值的值被销毁。

但是，如果我这样做 new std::vector<FooClass>(20) ，而不是使用默认构造函数，它似乎在做一些(对我来说)有点奇怪的事情。二十次，临时FooClass使用默认构造函数创建对象，使用临时构造函数通过复制构造函数构造数组的元素，然后销毁临时构造。

这对我来说真的没有意义；但我想知道也许我只是做错了什么。

代码

FooClass.h

#include <stdio.h>

class FooClass
{
public:
    FooClass()
    {
        printf("Foo %i Created!\n", NumFoos);

        myFooNumber = FooClass::NumFoos;
        ++FooClass::NumFoos;
        myIsACopy = false;
    }

    FooClass(const FooClass& Another)
    {
        printf("Foo %i (a copy of Foo %i) Created!\n", FooClass::NumFoos, Another.myFooNumber);

        myFooCopiedFrom = Another.myFooNumber;
        myFooNumber = FooClass::NumFoos;
        ++FooClass::NumFoos;
        myIsACopy = true;
    }

    void PrintMe()
    {
        if (myIsACopy)
            printf("I'm Foo %i (a copy of Foo %i)!\n", myFooNumber, myFooCopiedFrom);
        else
            printf("I'm Foo %i!\n", myFooNumber);
    }

    ~FooClass()
    {
        printf("Foo %i Deleted!\n", myFooNumber);
    }

private:
    int myFooCopiedFrom;
    int myFooNumber;
    bool myIsACopy;

private:
    static int NumFoos;

};

FooClass.cpp

#include "FooClass.h"

int FooClass::NumFoos = 0;

FooVector.cpp

// FooVector.cpp : Defines the entry point for the console application.

#include "stdafx.h"
#include <memory>
#include <vector>

#include "FooClass.h"

//#define USE_INITIALIZER

int _tmain(int argc, _TCHAR* argv[])
{
#ifdef USE_INITIALIZER
    std::vector<FooClass> myFooArray =
        std::vector<FooClass>(5, FooClass());
#else
    std::vector<FooClass> myFooArray =
        std::vector<FooClass>(5);
#endif

    for (int i=0; i < 5; ++i)
        myFooArray[i].PrintMe();

    printf("We're done!\n");

    return 0;
}

带默认初始化器的输出

    Foo 0 Created!
    Foo 1 (a copy of Foo 0) Created!
    Foo 2 (a copy of Foo 0) Created!
    Foo 3 (a copy of Foo 0) Created!
    Foo 4 (a copy of Foo 0) Created!
    Foo 5 (a copy of Foo 0) Created!
    Foo 0 Deleted!
    I'm Foo 1 (a copy of Foo 0)!
    I'm Foo 2 (a copy of Foo 0)!
    I'm Foo 3 (a copy of Foo 0)!
    I'm Foo 4 (a copy of Foo 0)!
    I'm Foo 5 (a copy of Foo 0)!
    We're done!

没有初始化器的输出

    Foo 0 Created!
    Foo 1 (a copy of Foo 0) Created!
    Foo 0 Deleted!
    Foo 2 Created!
    Foo 3 (a copy of Foo 2) Created!
    Foo 2 Deleted!
    Foo 4 Created!
    Foo 5 (a copy of Foo 4) Created!
    Foo 4 Deleted!
    Foo 6 Created!
    Foo 7 (a copy of Foo 6) Created!
    Foo 6 Deleted!
    Foo 8 Created!
    Foo 9 (a copy of Foo 8) Created!
    Foo 8 Deleted!
    I'm Foo 1 (a copy of Foo 0)!
    I'm Foo 3 (a copy of Foo 2)!
    I'm Foo 5 (a copy of Foo 4)!
    I'm Foo 7 (a copy of Foo 6)!
    I'm Foo 9 (a copy of Foo 8)!
    We're done!

问题

所以...我是否错误地设置了我的类，这是预期的行为？这可能是 Microsoft 实现 STL 的一个怪癖吗？

还是完全有其他解释？

最后的说明

我删除了 sgi 规范和评论，因为，作为 James's answer指出，sgi 规范不是实际规范。例如，参见 wikipedia's entry on C++ 的资源用于链接到真实规范的工作草案。感谢大家! :)

最佳答案

这是 Visual C++ 2010 标准库实现中的错误。这也在 Standard library containers producing a lot of copies on rvalues in GCC 中进行了讨论。 .

正确的行为取决于您的编译器和库设计的 C++ 规范版本。

在 C++98/C++03(上周之前的“当前”C++ 规范)中，您的代码的两个版本将调用相同的 std::vector 构造函数，这声明为:

vector(size_type n, const T& x = T(), const Allocator& = Allocator());

构造函数将 x 的 n 份复制到 vector 中。如果您没有显式提供要复制的 T 对象，则会通过默认参数隐式构造一个对象。如果您使用 Visual C++ 2008 编译代码，您会发现无论是否声明 USE_INITIALIZER，您的代码都会出现这种行为。在这两种情况下，您都将获得显示的“使用默认初始化程序输出”结果。

在 C++11(截至上周的当前版本)中，行为发生了变化。此构造函数已拆分为两个不同的构造函数:

vector(size_type n, const T& x, const Allocator& = Allocator()); // (1)
vector(size_type n);                                             // (2)

(1) 如果您明确提供要复制的对象并且 n 拷贝 x 被制作成 vector 。如果您不提供要复制的对象，则使用 (2):n 类型的 T 对象是在 vector 。根本没有复制。

因此，对于 C++11 实现，如果您声明 USE_INITIALIZER，您将获得与 C++03 中相同的行为。如果您不声明 USE_INITIALIZER，您应该得到以下输出。

Foo 0 Created!
Foo 1 Created!
Foo 2 Created!
Foo 3 Created!
Foo 4 Created!
I'm Foo 0!
I'm Foo 1!
I'm Foo 2!
I'm Foo 3!
I'm Foo 4!
We're done!

Visual C++ 2010 没有正确实现 C++11 std::vector 构造函数，它最终创建和销毁了一堆它不应该创建和销毁的对象。这应该在未来版本的 Visual C++ 中得到修复。

关于c++ - 为什么在将 std::vector 与默认构造函数一起使用时会出现异常行为？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7136275/