C++|初始化自定义结构体的几种方式

在C++中，初始化自定义结构体有多种方式，每种方式都有其适用场景。以下是一些常见的初始化方法：

1. 直接初始化：

   struct MyStruct {
       int x;
       double y;
   };
   
   MyStruct s1 = {10, 3.14};
   

2. 列表初始化（C++11及以后版本）：

   MyStruct s2{10, 3.14};
   

3. 使用构造函数：

   struct MyStruct {
       int x;
       double y;
       MyStruct(int x, double y) : x(x), y(y) {}
   };
   
   MyStruct s3(10, 3.14);
   

4. 使用std::initializer_list（C++11及以后版本）：

   struct MyStruct {
       int x;
       double y;
       MyStruct(std::initializer_list<int> init) {
           x = *init.begin();
           y = *(init.begin() + 1);
       }
   };
   
   MyStruct s4{10, 3.14};
   

5. 使用std::vector或std::array（C++11及以后版本）：

   struct MyStruct {
       int x;
       double y;
       MyStruct(const std::vector<double>& vec) : x(static_cast<int>(vec[0])), y(vec[1]) {}
   };
   
   std::vector<double> v = {10, 3.14};
   MyStruct s5(v);
   

6. 使用std::tuple（C++11及以后版本）：

   struct MyStruct {
       int x;
       double y;
       MyStruct(const std::tuple<int, double>& t) : x(std::get<0>(t)), y(std::get<1>(t)) {}
   };
   
   std::tuple<int, double> t = std::make_tuple(10, 3.14);
   MyStruct s6(t);
   

7. 使用std::map或std::unordered_map（C++11及以后版本）：

   struct MyStruct {
       int x;
       double y;
       MyStruct(const std::map<std::string, double>& m) : x(static_cast<int>(m.at("x"))), y(m.at("y")) {}
   };
   
   std::map<std::string, double> m = {{"x", 10}, {"y", 3.14}};
   MyStruct s7(m);
   

8. 使用std::pair（C++11及以后版本）：

   struct MyStruct {
       int x;
       double y;
       MyStruct(const std::pair<int, double>& p) : x(p.first), y(p.second) {}
   };
   
   std::pair<int, double> p = {10, 3.14};
   MyStruct s8(p);
   

9. 使用memset（不推荐，除非对性能有特殊要求）：

   MyStruct s9;
   std::memset(&s9, 0, sizeof(MyStruct));
   s9.x = 10;
   s9.y = 3.14;
   

10. 使用new操作符：

    MyStruct* s10 = new MyStruct{10, 3.14};
    

每种方法都有其适用场景，例如直接初始化和列表初始化是最简单直观的，而使用构造函数则提供了更多的灵活性和控制。使用std::initializer_list、std::vector、std::tuple、std::map、std::pair等则可以在初始化时提供更多的数据结构支持。使用memset和new操作符则适用于特定的性能优化场景或动态内存管理需求。选择哪种方法取决于具体的使用场景和需求。