在 C++ 中，数据类型的声明、初始化和赋值可以通过多种方式实现。复合数据类型包括数组、字符串、容器（如 std::vector、std::list、std::map 等），以及用户自定义类型（如 struct 和 class）。以下是这些数据类型的声明、初始化和赋值的形式介绍。

基本数据类型

int

声明：

int a;

初始化：

int a = 10;       // 直接初始化
int b(20);        // 构造函数初始化
int c{30};        // 列表初始化（C++11及以上）

赋值：

int d = a;        // 复制初始化
d = b;            // 赋值操作

float

声明：

float f;

初始化：

float f = 3.14f;  // 直接初始化
float g(2.71f);   // 构造函数初始化
float h{1.61f};   // 列表初始化（C++11及以上）

赋值：

float i = f;      // 复制初始化
i = g;            // 赋值操作

char

声明：

char c;

初始化：

char c = 'A';     // 直接初始化
char d('B');      // 构造函数初始化
char e{'C'};      // 列表初始化（C++11及以上）

赋值：

char f = c;       // 复制初始化
f = d;            // 赋值操作

复合数据类型

std::string

声明：

std::string str;

初始化：

std::string str = "Hello";              // 直接初始化
std::string str2("World");              // 构造函数初始化
std::string str3{"C++"};                // 列表初始化（C++11及以上）

赋值：

std::string str4 = str;                 // 复制初始化
str4 = str2;                            // 赋值操作

std::vector

声明：

std::vector<int> vec;

初始化：

std::vector<int> vec = {1, 2, 3};       // 列表初始化（C++11及以上）
std::vector<int> vec2(5, 10);           // 构造函数初始化，5个元素，每个值为10
std::vector<int> vec3{4, 5, 6};         // 列表初始化（C++11及以上）

赋值：

std::vector<int> vec4 = vec;            // 复制初始化
vec4 = vec2;                            // 赋值操作

用户自定义类型

struct

声明：

struct Point {
    int x;
    int y;
};

初始化：

Point p1 = {1, 2};                      // 列表初始化
Point p2{3, 4};                         // 列表初始化（C++11及以上）
Point p3 = Point{5, 6};                 // 列表初始化（C++11及以上）

赋值：

Point p4 = p1;                          // 复制初始化
p4 = p2;                                // 赋值操作

class

声明：

class MyClass {
public:
    MyClass(int val) : data(val) {}
    int data;
};

初始化：

MyClass obj1(10);                       // 构造函数初始化
MyClass obj2 = MyClass(20);             // 直接初始化
MyClass obj3{30};                       // 列表初始化（C++11及以上）

赋值：

MyClass obj4 = obj1;                    // 复制初始化
obj4 = obj2;                            // 赋值操作

智能指针

std::shared_ptr

声明：

std::shared_ptr<int> sptr;

初始化：

std::shared_ptr<int> sptr = std::make_shared<int>(10); // make_shared初始化
std::shared_ptr<int> sptr2(new int(20));               // 直接new初始化

赋值：

std::shared_ptr<int> sptr3 = sptr;      // 复制初始化
sptr3 = sptr2;                          // 赋值操作

std::unique_ptr

声明：

std::unique_ptr<int> uptr;

初始化：

std::unique_ptr<int> uptr = std::make_unique<int>(10); // make_unique初始化
std::unique_ptr<int> uptr2(new int(20));               // 直接new初始化

赋值：

// std::unique_ptr 不支持直接复制
std::unique_ptr<int> uptr3 = std::move(uptr); // 移动初始化
uptr3 = std::move(uptr2);                     // 移动赋值

数组

普通数组

声明：

int arr[5];

初始化：

int arr1[5] = {1, 2, 3, 4, 5};  // 列表初始化
int arr2[5] = {1, 2};           // 部分初始化，未指定的元素初始化为 0
int arr3[5] = {};               // 全部初始化为 0

赋值：

int arr4[5];
std::copy(std::begin(arr1), std::end(arr1), std::begin(arr4));  // 复制数组内容

std::array

声明：

std::array<int, 5> arr;

初始化：

std::array<int, 5> arr1 = {1, 2, 3, 4, 5};  // 列表初始化
std::array<int, 5> arr2{1, 2, 3, 4, 5};     // 列表初始化（C++11 及以上）
std::array<int, 5> arr3 = {};               // 全部初始化为 0

赋值：

std::array<int, 5> arr4 = arr1;  // 复制初始化
arr4 = arr2;                     // 赋值操作

std::list

声明：

std::list<int> lst;

初始化：

std::list<int> lst1 = {1, 2, 3};       // 列表初始化（C++11 及以上）
std::list<int> lst2(5, 10);            // 构造函数初始化，5 个元素，每个值为 10
std::list<int> lst3{4, 5, 6};          // 列表初始化（C++11 及以上）
std::list<int> lst4(lst1.begin(), lst1.end());  // 迭代器范围初始化

赋值：

std::list<int> lst5 = lst1;            // 复制初始化
lst5 = lst2;                           // 赋值操作

std::map

声明：

std::map<std::string, int> map;

初始化：

std::map<std::string, int> map1 = {{"one", 1}, {"two", 2}};  // 列表初始化（C++11 及以上）
std::map<std::string, int> map2(map1.begin(), map1.end());   // 迭代器范围初始化

赋值：

std::map<std::string, int> map3 = map1;  // 复制初始化
map3 = map2;                             // 赋值操作

总结

在 C++ 中，复合数据类型的声明、初始化和复制有多种形式。现代 C++ 提供了许多新的特性，如列表初始化、智能指针等，使得代码更加安全和简洁。根据具体需求选择合适的方法，可以有效提高代码的可读性和可维护性。