C++ 在c+中实现静态构造函数+；不'；行不通

在

static\u构造函数

的构造函数内调用的

push\u back

，不会反映出来。为什么?

#include <iostream>
#include <vector>
#include<memory>
#include<string>

using namespace std;

class has_static_constructor
{
    public:
    friend class static_constructor;
    static vector<int> v;



         class static_constructor
        {
            public:

             vector<int> * upt; //&v;
            static_constructor()
            {
                cout<<"inside static_constructor";
                upt = &has_static_constructor::v;
                has_static_constructor::v.push_back(1);
                has_static_constructor::v.push_back(20);
            }

        } ;

        static std::unique_ptr<has_static_constructor::static_constructor> upt ;
};



unique_ptr<has_static_constructor::static_constructor> has_static_constructor::upt(new has_static_constructor::static_constructor());

vector< int > has_static_constructor::v(2,100);

int main() {
    // your code goes here

    for (std::vector<int>::const_iterator i = has_static_constructor::v.begin(); i != has_static_constructor::v.end(); ++i)
    {   std::cout << *i << ' ';
        cout<<"\n I was here\n";
    }

    return 0;
}

static\u constructor（）

在

具有\u static\u constructor:：v

初始化之前被调用

移动

unique_ptr has_static_constructor:：upt（新的has_static_constructor:：static_constructor（））；

之后

vector具有静态构造函数：：v（2100）；

有预期的行为

但是最好完全避免这些全局构造函数。

在

具有静态构造函数：：v

初始化之前调用静态构造函数（）

移动

unique_ptr has_static_constructor:：upt（新的has_static_constructor:：static_constructor（））；

之后

vector具有静态构造函数：：v（2100）；

有预期的行为

但是最好完全避免这些全局构造函数。

在

具有静态构造函数：：v

初始化之前调用静态构造函数（）

移动

unique_ptr has_static_constructor:：upt（新的has_static_constructor:：static_constructor（））；

之后

vector具有静态构造函数：：v（2100）；

有预期的行为

但是最好完全避免这些全局构造函数。

在

具有静态构造函数：：v

初始化之前调用静态构造函数（）

移动

unique_ptr has_static_constructor:：upt（新的has_static_constructor:：static_constructor（））；

之后

vector具有静态构造函数：：v（2100）；

有预期的行为

---

但是最好完全避免那些全局的。

您可能想看看这种排序代码的方法。它删除了所有的初始化顺序依赖项，在我看来，它将公共接口与静态数据的内部实现巧妙地分开

#include <iostream>
#include <vector>


class has_static_constructor
{
    // note - all private

    struct static_data {
        static_data()
        : _v(2, 100)
        {
            _v.push_back(1);
            _v.push_back(20);
        }
        std::vector<int> _v;
    };

    static static_data& statics() {
        static static_data sd;
        return sd;
    }

    // public interface
public:

    static std::vector<int>& v() { return statics()._v; }

};

auto main() -> int
{
    for (const auto& i : has_static_constructor::v())
    {
        std::cout << i << std::endl;
    }
    return 0;
}

---

您可能想看看这种排序代码的方法。它删除了所有的初始化顺序依赖项，在我看来，它将公共接口与静态数据的内部实现巧妙地分开

#include <iostream>
#include <vector>


class has_static_constructor
{
    // note - all private

    struct static_data {
        static_data()
        : _v(2, 100)
        {
            _v.push_back(1);
            _v.push_back(20);
        }
        std::vector<int> _v;
    };

    static static_data& statics() {
        static static_data sd;
        return sd;
    }

    // public interface
public:

    static std::vector<int>& v() { return statics()._v; }

};

auto main() -> int
{
    for (const auto& i : has_static_constructor::v())
    {
        std::cout << i << std::endl;
    }
    return 0;
}

---

您可能想看看这种排序代码的方法。它删除了所有的初始化顺序依赖项，在我看来，它将公共接口与静态数据的内部实现巧妙地分开

#include <iostream>
#include <vector>


class has_static_constructor
{
    // note - all private

    struct static_data {
        static_data()
        : _v(2, 100)
        {
            _v.push_back(1);
            _v.push_back(20);
        }
        std::vector<int> _v;
    };

    static static_data& statics() {
        static static_data sd;
        return sd;
    }

    // public interface
public:

    static std::vector<int>& v() { return statics()._v; }

};

auto main() -> int
{
    for (const auto& i : has_static_constructor::v())
    {
        std::cout << i << std::endl;
    }
    return 0;
}

---

您可能想看看这种排序代码的方法。它删除了所有的初始化顺序依赖项，在我看来，它将公共接口与静态数据的内部实现巧妙地分开

#include <iostream>
#include <vector>


class has_static_constructor
{
    // note - all private

    struct static_data {
        static_data()
        : _v(2, 100)
        {
            _v.push_back(1);
            _v.push_back(20);
        }
        std::vector<int> _v;
    };

    static static_data& statics() {
        static static_data sd;
        return sd;
    }

    // public interface
public:

    static std::vector<int>& v() { return statics()._v; }

};

auto main() -> int
{
    for (const auto& i : has_static_constructor::v())
    {
        std::cout << i << std::endl;
    }
    return 0;
}

---

---

你到底想解决什么问题。毫无疑问，已经有一个众所周知的解决方案。最好在帖子中发布代码，而不是链接到另一个可能消失的站点上的代码。在任何情况下，类的构造函数

static\u构造函数

正在访问

的静态成员has\u static\u构造函数

，然后再构造该成员。这样做的结果是根据C++标准的未定义行为。这意味着任何行为都是可以接受的，包括您看到的。@Peter

upt=&has\u static\u constructor:：vpush\u back（）

之前，应该初始化

v

内部的

静态构造函数（）。我是不是错过了什么？@ RigHordgdg:我只是出于好奇，试图在C++中实现静态构造函数。我正在学习语言。@q：这是这些静态的定义顺序（因为它们都在一个编译单元中），而不是它们在类定义中声明的顺序。虽然您已经更新了您的帖子，但是您遗漏了链接到的代码中的静态定义。您实际要解决的问题是什么。毫无疑问，已经有一个众所周知的解决方案。最好在帖子中发布代码，而不是链接到另一个可能消失的站点上的代码。在任何情况下，类的构造函数
static\u构造函数
正在访问
的静态成员has\u static\u构造函数
，然后再构造该成员。这样做的结果是根据C++标准的未定义行为。这意味着任何行为都是可以接受的，包括您看到的。@Peter
upt=&has\u static\u constructor:：vpush\u back（）
之前，应该初始化
v
内部的
静态构造函数（）。我是不是错过了什么？@ RigHordgdg:我只是出于好奇，试图在C++中实现静态构造函数。我正在学习语言。@q：这是这些静态的定义顺序（因为它们都在一个编译单元中），而不是它们在类定义中声明的顺序。虽然您已经更新了您的帖子，但是您遗漏了链接到的代码中的静态定义。您实际要解决的问题是什么。毫无疑问，已经有一个众所周知的解决方案。最好在帖子中发布代码，而不是链接到另一个可能消失的站点上的代码。在任何情况下，类的构造函数
static\u构造函数
正在访问
的静态成员has\u static\u构造函数
，然后再构造该成员。这样做的结果是根据C++标准的未定义行为。这意味着任何行为都是可以接受的，包括您看到的。@Peter
upt=&has\u static\u constructor:：vpush\u back（）
之前，应该初始化
v
内部的
静态构造函数（）。我是不是错过了什么？@ RigHordgdg:我只是出于好奇，试图在C++中实现静态构造函数。我正在学习语言。@q：这是这些静态的定义顺序（因为它们都在一个编译单元中），而不是它们在类定义中声明的顺序。虽然你已经更新了
100
100
1
20