构造函数

Posted on Edited on In

对象的副本

在 C++ 中，一个对象的副本是指创建了原始对象的一个拷贝，这个拷贝具有与原始对象相同的属性和状态。换句话说，副本是源对象的一个独立副本，它们的值相同，但是它们在内存中占用不同的空间。

创建对象副本的过程通常称为拷贝构造。当我们创建一个新对象时，如果使用另一个已经存在的对象作为模板，那么新对象就是原始对象的一个副本。通常，这会涉及调用拷贝构造函数。

以下是一个简单的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>

class MyClass {
public:
    int x;

    MyClass(int a) : x(a) {} // 构造函数
    MyClass(const MyClass& other) : x(other.x) {} // 拷贝构造函数
};

int main() {
    MyClass obj1(10); // 使用构造函数创建一个对象
    MyClass obj2(obj1); // 使用拷贝构造函数创建 obj1 的一个副本

    std::cout << "obj1.x = " << obj1.x << std::endl; // 输出：obj1.x = 10
    std::cout << "obj2.x = " << obj2.x << std::endl; // 输出：obj2.x = 10

    return 0;
}

在这个示例中，我们有一个名为 MyClass 的类，它具有一个整数成员变量 x。我们为 MyClass 提供了一个构造函数和一个拷贝构造函数。在 main 函数中，我们首先使用构造函数创建了一个名为 obj1 的对象，然后使用拷贝构造函数创建了 obj1 的一个副本，名为 obj2。obj2 是 obj1 的副本，因为它具有与 obj1 相同的属性（在这种情况下，是 x 的值）。

请注意，尽管 obj1 和 obj2 具有相同的值，但它们在内存中是独立的。这意味着更改其中一个对象的状态不会影响另一个对象。

拷贝构造函数通常不应该是explicit的

在 C++ 中，explicit 关键字用于指定构造函数或类型转换操作不应该进行隐式类型转换。换句话说，explicit 可以防止在需要显式构造的情况下发生隐式类型转换。

当我们说 “拷贝构造函数通常不应该是 explicit 的” 时，意味着拷贝构造函数应该允许隐式类型转换，以方便编译器在需要时自动执行拷贝构造。

拷贝构造函数允许隐式转换的原因是因为它们在很多情况下被编译器隐式调用，例如：

  1. 将一个对象作为函数参数传递时。
  2. 从函数返回一个对象时。
  3. 使用赋值运算符初始化一个对象时。

在这些情况下，如果拷贝构造函数被声明为 explicit，则可能会导致编译错误，因为编译器不能隐式调用拷贝构造函数。

以下是一个例子，说明为什么拷贝构造函数不应该是 explicit 的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class MyClass {
public:
    int x;

    MyClass(int a) : x(a) {} // 构造函数
    explicit MyClass(const MyClass& other) : x(other.x) {} // explicit 拷贝构造函数（不推荐）
};

void some_function(MyClass obj) {
    // ... do something ...
}

int main() {
    MyClass obj1(10);

    // 下面这行代码会导致编译错误，因为拷贝构造函数是 explicit 的，编译器不能隐式调用它。
    some_function(obj1);

    return 0;
}

在这个示例中，我们将拷贝构造函数声明为 explicit，这导致了编译错误。当我们尝试将 obj1 传递给 some_function 时，编译器无法隐式调用拷贝构造函数，因此会报错。为了避免这种情况，拷贝构造函数通常应该允许隐式类型转换，不应该被声明为 explicit。

如果不想上面这个报错，也不去掉explicit，应该怎么做

如果您希望保留 explicit 关键字并避免编译错误，您需要显式地调用拷贝构造函数。在这种情况下，可以使用以下方法：

  1. 使用花括号 {} 或圆括号 () 显式地创建一个临时对象并传递给 some_function。
  2. 使用 static_cast 来显式地创建一个副本。

以下是两种方法的示例：

方法 1：使用花括号 {} 或圆括号 () 显式地创建一个临时对象。

1
2
3
4
5
6
7
8
9
10
11
int main() {
    MyClass obj1(10);

    // 使用花括号显式地调用拷贝构造函数
    some_function(MyClass{obj1});

    // 或者，使用圆括号显式地调用拷贝构造函数
    some_function(MyClass(obj1));

    return 0;
}

方法 2：使用 static_cast 来显式地创建一个副本。

1
2
3
4
5
6
7
8
int main() {
    MyClass obj1(10);

    // 使用 static_cast 显式地调用拷贝构造函数
    some_function(static_cast<MyClass>(obj1));

    return 0;
}

在这些示例中，我们显式地调用了拷贝构造函数，因此编译器不再需要隐式地调用它。这使得代码能够正常编译和运行，尽管拷贝构造函数被声明为 explicit。

static_cast

static_cast 是 C++ 中一种用于执行编译时类型转换的操作符。它可以在相关类型之间进行转换，例如将指针或引用的类型从基类转换为派生类，将枚举类型转换为整数，或在数值类型（如 int、float、double 等）之间进行转换。与 C 风格的强制类型转换相比，static_cast 提供了更严格的类型检查，因此更安全。

以下是使用 static_cast 的一些示例：

  1. 在数值类型之间进行转换：
1
2
3
4
5
int main() {
    int i = 42;
    double d = static_cast<double>(i); // 将 int 类型转换为 double 类型
    return 0;
}
  1. 将枚举类型转换为整数：
1
2
3
4
5
6
7
enum Color { RED, GREEN, BLUE };

int main() {
    Color c = RED;
    int color_code = static_cast<int>(c); // 将枚举类型转换为 int 类型
    return 0;
}
  1. 在类层次结构中进行向上转换（从派生类到基类）：
1
2
3
4
5
6
7
8
9
class Base {};
class Derived : public Base {};

int main() {
    Derived *derived_ptr = new Derived();
    Base *base_ptr = static_cast<Base*>(derived_ptr); // 将 Derived* 类型转换为 Base* 类型
    delete derived_ptr;
    return 0;
}

需要注意的是，static_cast 不能转换无关的类型，例如将 void* 转换为其他类型的指针，或将非类类型转换为类类型。对于这些情况，可以使用其他类型的转换操作符，如 reinterpret_cast 或 dynamic_cast。注意：double d = (int) i即为C中的强制类型转换。

static_cast 提供了更严格的类型检查是如何体现的

static_cast 提供更严格类型检查的体现主要在于它在编译时执行类型检查，而不是在运行时。这意味着，如果类型转换不安全或不正确，编译器将在编译期间发出错误或警告，而不是在运行时导致未定义行为。

以下是一些static_cast类型检查的例子：

  1. 在数值类型之间进行转换时，static_cast 会检查转换是否合理。例如，将一个 double 转换为 int 会丢失小数部分，但这种转换仍然是明确的，因此编译器允许它。然而，如果转换可能导致数据损失或无法执行，编译器将发出警告或错误。

  2. 在类层次结构中进行向上转换（从派生类到基类）时，static_cast 会确保两个类之间存在继承关系。例如，将一个 Derived* 转换为 Base* 是允许的，前提是 Derived 类真正继承自 Base 类。如果这两个类没有继承关系，编译器将发出错误。

与 C 风格的强制类型转换相比，static_cast 更安全，因为 C 风格的强制类型转换不会进行类型检查。例如，您可以使用 C 风格的强制类型转换将一个 float 指针转换为一个 int 指针，尽管这样做可能导致未定义行为。使用 static_cast 进行此类转换会导致编译错误。

总之，static_cast 在编译时进行类型检查，确保转换是明确的、安全的且合理的。这使得它比 C 风格的强制类型转换更安全。然而，应谨慎使用 static_cast，并且只在确信转换是安全的情况下使用，因为它仍然可能导致数据损失或其他问题，尤其是在数值类型转换和向下转换（从基类到派生类）时。在这些情况下，应考虑使用其他类型转换操作符，如 dynamic_cast 或 reinterpret_cast。

为什么输出color_code是0呢

在您提供的代码示例中，color_code 的值为 0，因为 Color 枚举中的 RED 成员被隐式地赋予了整数值 0。C++ 中的枚举成员会从 0 开始递增地分配整数值，除非您明确地为它们指定其他值。因此，在这个例子中，Color 枚举成员的整数值如下：

1
enum Color { RED, GREEN, BLUE };
  • RED 的值为 0
  • GREEN 的值为 1
  • BLUE 的值为 2

当您将 c 赋值为 RED 并将其转换为 int 类型时，color_code 变量将接收整数值 0，因为这是 RED 枚举成员对应的值。这就是为什么 color_code 的输出值为 0 的原因。

如何赋值其他值呢

在 C++ 中，您可以为枚举成员显式分配整数值。为此，只需在枚举成员后使用等号 (=) 并指定所需的整数值。以下是一个示例，说明如何为 Color 枚举的成员分配自定义整数值：

1
enum Color { RED = 3, GREEN = 7, BLUE = 10 };

在这个例子中，我们将 RED 的值设为 3，GREEN 的值设为 7，而 BLUE 的值设为 10。现在，当您将枚举成员转换为整数类型时，它们将具有这些显式分配的值。例如：

1
2
3
4
5
6
int main() {
    Color c = RED;
    int color_code = static_cast<int>(c); // 将枚举类型转换为 int 类型
    std::cout << "Color code for RED: " << color_code << std::endl; // 输出：Color code for RED: 3
    return 0;
}

在这个例子中，color_code 的值为 3，因为我们为 RED 枚举成员分配了整数值 3。

合成拷贝构造函数和拷贝构造函数有什么不同吗

拷贝构造函数和合成拷贝构造函数的主要区别在于它们的来源和行为。拷贝构造函数是用户自定义的，而合成拷贝构造函数是编译器自动生成的。

  1. 拷贝构造函数（User-defined copy constructor）： 当您在类中显式地定义一个拷贝构造函数时，就是创建了一个用户自定义的拷贝构造函数。这意味着您可以根据需要自定义拷贝行为。例如，您可能需要执行深拷贝以避免潜在的浅拷贝问题。自定义拷贝构造函数的例子如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyClass {
public:
    int *data;

    MyClass(int value) {
        data = new int(value);
    }

    // 用户自定义的拷贝构造函数
    MyClass(const MyClass &other) {
        data = new int(*other.data); // 深拷贝
    }

    ~MyClass() {
        delete data;
    }
};
  1. 合成拷贝构造函数（Synthesized copy constructor）： 当您没有在类中显式地定义拷贝构造函数时，编译器会自动生成一个合成拷贝构造函数。合成拷贝构造函数执行成员逐个拷贝，即：对于类类型的成员，调用其拷贝构造函数；对于内置类型的成员，直接进行值拷贝。需要注意的是，合成拷贝构造函数执行的是浅拷贝，这可能导致潜在的内存问题（例如，当类包含指针成员时）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MyClass {
public:
    int *data;

    MyClass(int value) {
        data = new int(value);
    }

    // 编译器自动生成的合成拷贝构造函数
    // MyClass(const MyClass &other) = default;

    ~MyClass() {
        delete data;
    }
};

总之，拷贝构造函数和合成拷贝构造函数的主要区别在于：拷贝构造函数是用户自定义的，可以自定义拷贝行为；合成拷贝构造函数是编译器自动生成的，执行逐个成员的拷贝。如果类中没有显式地定义拷贝构造函数，编译器将自动生成一个合成拷贝构造函数。如果您需要自定义拷贝行为（例如执行深拷贝），则应在类中显式地定义拷贝构造函数。

拷贝初始化除了在使用=定义变量时会发生，还有什么情况下会发生

拷贝初始化不仅在使用等号 = 定义变量时会发生，还会在以下几种情况下发生：

  1. 作为函数参数传递对象时： 当将对象作为函数参数传递时，如果参数是按值传递的（即不是引用或指针），则会发生拷贝初始化。
1
2
3
4
5
6
7
8
9
void foo(MyClass obj) {
    // ...
}

int main() {
    MyClass a;
    foo(a); // 拷贝初始化：将 a 作为参数传递给函数 foo
    return 0;
}
  1. 从函数返回对象时： 当从函数返回一个对象时，会发生拷贝初始化。这通常涉及到返回值优化（RVO），在许多情况下，编译器会优化这个过程，避免不必要的拷贝。
1
2
3
4
5
6
7
8
9
10
MyClass create_object() {
    MyClass obj;
    // ...
    return obj; // 拷贝初始化：从函数返回一个对象
}

int main() {
    MyClass b = create_object(); // 拷贝初始化：接收从函数返回的对象
    return 0;
}
  1. 使用花括号 {} 或圆括号 () 初始化对象时： 当用另一个对象初始化新对象时，如果使用花括号 {} 或圆括号 ()，也会发生拷贝初始化。
1
2
3
4
5
6
int main() {
    MyClass c;
    MyClass d(c); // 拷贝初始化：使用圆括号初始化对象
    MyClass e{c}; // 拷贝初始化：使用花括号初始化对象
    return 0;
}
  1. 初始化列表中的成员初始化： 当在类的构造函数的初始化列表中初始化成员对象时，也会发生拷贝初始化。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class AnotherClass {
public:
    MyClass obj;

    AnotherClass(const MyClass &other_obj) : obj(other_obj) {
        // 拷贝初始化：在初始化列表中初始化成员对象
    }
};

int main() {
    MyClass f;
    AnotherClass g(f); // 拷贝初始化：将 f 传递给 AnotherClass 的构造函数
    return 0;
}

在以上各种情况下，都可能发生拷贝初始化。然而，需要注意的是，编译器通常会尽可能地优化这些拷贝操作，以提高程序的性能。