c++学习：构造函数

最新推荐文章于 2024-05-10 20:06:44 发布
最新推荐文章于 2024-05-10 20:06:44 发布
阅读量927 收藏 19
点赞数 25
分类专栏： c++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59669309/article/details/136359396
版权

目录

普通构造函数

带参数构造函数

拷贝构造函数

基本概念及发生条件

拷贝构造函数的典型声明如下：

示例代码

浅拷贝

深拷贝

遵循规则三则

遵循规则三则的简单示例：

避免不必要的拷贝

 使用引用传递对象

使用移动语义

拷贝构造函数的隐式调用

作为函数参数传递（按值传递）

从函数返回对象（按值返回）

初始化另一个对象

禁用拷贝构造函数

使用 delete 关键字

使用 private 声明

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行，每次都会构造成员变量的初始化值，内存空间等。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于 为某些成员变量设置初始值

普通构造函数

#include <iostream>
#include <string>
using namespace std; // 使用std命名空间
class Car {
public:
    string brand; // 不需要使用std::string
    int year;
    // 无参构造函数
    Car() {
        brand = "未知";
        year = 0;
        cout << "无参构造函数被调用" << endl; // 不需要使用std::cout和std::endl
    }
    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};
int main() {
    Car myCar; // 创建Car对象
    myCar.display(); // 显示车辆信息
    return 0;
}

带参数构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象 赋初始值，如下面的例子所示

#include <iostream>
#include <string>
using namespace std;
class Car {
    public:
    string brand;
    int year;
    // 带参数的构造函数，使用常规的赋值方式
    Car(string b, int y) {
        brand = b;
        year = y;
    }
    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};
int main() {
    Car myCar("Toyota", 2020); // 使用带参数的构造函数创建Car对象
    myCar.display(); // 显示车辆信息
    return 0;
}

拷贝构造函数

基本概念及发生条件

  1. 当一个新对象被创建为另一个同类型的现有对象的副本时：
    1. 例如： MyClass obj1 = obj2; 或 MyClass obj1(obj2); ，其中 obj2 是现有的对象
  2. 将对象作为参数传递给函数时（按值传递）：
    1. 当对象作为参数传递给函数，并且参数不是引用时，会使用拷贝构造函数创建函数内部的对象 副本。
  3. 从函数返回对象时（按值返回）：
    1. 当函数返回对象，并且没有使用引用或指针时，拷贝构造函数用于从函数返回值创建副本。
  4. 初始化数组或容器中的元素时：
    1. 例如，在创建一个包含对象的数组时，数组中的每个对象都是通过拷贝构造函数初始化的。

拷贝构造函数的典型声明如下：

class MyClass {
public:
    MyClass(const MyClass& other);
};

其中， other 是对同类型对象的引用，通常是常量引用。

示例代码

#include <iostream>
#include <string>
using namespace std;
class Car {
public:
    string brand;
    int year;
    // 常规构造函数
    Car(string b, int y) : brand(b), year(y) {}
    // 拷贝构造函数
    Car(const Car& other) {
        brand = other.brand;
        year = other.year;
        cout << "拷贝构造函数被调用" << endl;
    }
    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};
int main() {
    Car car1("Toyota", 2020); // 使用常规构造函数
    Car car2 = car1; // 使用拷贝构造函数
    car1.display();
    car2.display();
    return 0;
}

浅拷贝

浅拷贝只复制对象的成员变量的值。如果成员变量是指针，则复制指针的值（即内存地址），而不是指 针所指向的实际数据。这会导致多个对象共享相同的内存地址。

#include <iostream>
using namespace std;
class Shallow {
public:
    int* data;
    Shallow(int d) {
        //(d)：这是初始化表达式。在这里，分配的 int 类型内存被初始化为 d 的值。如果 d 的值是
20，那么分配的内存将被初始化为 20。
        data = new int(d); // 动态分配内存
        cout << "观察数据：" << endl;
        cout << d << endl;
        cout << *data << endl;
        cout << "观察内存在构造函数中：" << endl;
        cout << data << endl;
    }
    // 默认的拷贝构造函数是浅拷贝
    ~Shallow() {
        delete data; // 释放内存
    }
};
int main() {
    Shallow obj1(20);
    Shallow obj2 = obj1; // 浅拷贝
    cout << "观察内存在main函数obj2的data地址：" << endl;
    cout << obj2.data << endl;
    cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;
    return 0;
}

在这个例子中， obj2 是通过浅拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向相同的内 存地址。

当 obj1 和 obj2 被销毁时，同一内存地址会被尝试释放两次，导致潜在的运行时错误。

深拷贝

深拷贝复制对象的成员变量的值以及指针所指向的实际数据。这意味着创建新的独立副本，避免了共享 内存地址的问题。

#include <iostream>
using namespace std;
class Deep {
public:
    int* data;
    Deep(int d) {
        data = new int(d); // 动态分配内存
        cout << "观察数据：" << endl;
        cout << d << endl;
        cout << *data << endl;
        cout << "观察内存在构造函数中：" << endl;
        cout << data << endl;
    }
    // 显式定义深拷贝的拷贝构造函数
    Deep(const Deep& source) {
        data = new int(*source.data); // 复制数据，而不是地址
        cout << "深拷贝构造函数\n";
    }
    ~Deep() {
        delete data; // 释放内存
    }
};
int main() {
    Deep obj1(20);
    Deep obj2 = obj1; // 深拷贝
    cout << "观察内存在main函数obj2的data地址：" << endl;
    cout << obj2.data << endl;
    cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;
    return 0;
}

在这个例子中， obj2 是通过深拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向不同的内 存地址。每个对象有自己的内存副本，因此不会相互影响，避免了潜在的运行时错误。

遵循规则三则

在 C++ 中，规则三则（Rule of Three）是一个面向对象编程原则，它涉及到类的拷贝控制。规则三则指 出，如果你需要显式地定义或重载类的任何一个拷贝控制操作（拷贝构造函数、拷贝赋值运算符、析构 函数），那么你几乎肯定需要显式地定义或重载所有三个。这是因为这三个功能通常都是用于管理动态 分配的资源，比如在堆上分配的内存。

遵循规则三则的简单示例：

#include <iostream>
#include <cstring>
class MyClass {
private:
    char* buffer;
public:
    // 构造函数
    MyClass(const char* str) {
        if (str) {
            buffer = new char[strlen(str) + 1];
            strcpy(buffer, str);
        } else {
            buffer = nullptr;
        }
    }
    // 析构函数
    ~MyClass() {
        delete[] buffer;
    }
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        if (other.buffer) {
            buffer = new char[strlen(other.buffer) + 1];
            strcpy(buffer, other.buffer);
        } else {
            buffer = nullptr;
        }
    }
    // 拷贝赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete[] buffer; // 首先删除当前对象的资源
            if (other.buffer) {
                buffer = new char[strlen(other.buffer) + 1];
                strcpy(buffer, other.buffer);
            } else {
                buffer = nullptr;
            }
        }
        return *this;
    }
};
int main() {
    MyClass obj1("Hello");
    MyClass obj2 = obj1; // 调用拷贝构造函数
    MyClass obj3("World");
    obj3 = obj1; // 调用拷贝赋值运算符
    return 0;
}

在这个例子中：

  • 构造函数为成员变量 buffer 分配内存，并复制给定的字符串。
  • 析构函数释放 buffer 所占用的内存，以避免内存泄露。
  • 拷贝构造函数创建一个新对象作为另一个现有对象的副本，并为其分配新的内存，以避免多个对象 共享同一内存。
  • 拷贝赋值运算符更新对象时，首先释放原有资源，然后根据新对象的状态分配新资源

这个类遵循规则三则，确保了动态分配资源的正确管理，避免了内存泄露和浅拷贝问题。 

避免不必要的拷贝

避免不必要的拷贝是 C++ 程序设计中的一个重要原则，尤其是在处理大型对象或资源密集型对象时。使 用引用（包括常量引用）和移动语义（C++11 引入）是实现这一目标的两种常见方法。

 使用引用传递对象

通过使用引用（尤其是常量引用）来传递对象，可以避免在函数调用时创建对象的副本。

#include <iostream>
#include <vector>
using namespace std;
class LargeObject {
    // 假设这是一个占用大量内存的大型对象
};
void processLargeObject(const LargeObject& obj) {
    // 处理对象，但不修改它
    cout << "Processing object..." << endl;
}
int main() {
    LargeObject myLargeObject;
    processLargeObject(myLargeObject); // 通过引用传递，避免拷贝
    return 0;
}

在这个例子中， processLargeObject 函数接受一个对 LargeObject 类型的常量引用，避免了在函数 调用时复制整个 LargeObject 。

使用移动语义

C++11 引入了移动语义，允许资源（如动态分配的内存）的所有权从一个对象转移到另一个对象，这避 免了不必要的拷贝。

#include <iostream>
#include <utility> // 对于 std::move
using namespace std;
class MovableObject {
public:
    MovableObject() {
        // 构造函数
    }
    MovableObject(const MovableObject& other) {
        // 拷贝构造函数（可能很昂贵）
    }
    MovableObject(MovableObject&& other) noexcept {
        // 移动构造函数（轻量级）
        // 转移资源的所有权
    }
    MovableObject& operator=(MovableObject&& other) noexcept {
        // 移动赋值运算符
        // 转移资源的所有权
        return *this;
    }
};
MovableObject createObject() {
    MovableObject obj;
    return obj; // 返回时使用移动语义，而非拷贝
}
int main() {
    MovableObject obj = createObject(); // 使用移动构造函数
    return 0;
}

在这个例子中， MovableObject 类有一个移动构造函数和一个移动赋值运算符，它们允许对象的资源 （如动态分配的内存）在赋值或返回时被“移动”而非复制。这减少了对资源的不必要拷贝，提高了效率。

通过这些方法，你可以在 C++ 程序中有效地减少不必要的对象拷贝，尤其是对于大型或资源密集型的对 象。

拷贝构造函数的隐式调用

在 C++ 中，拷贝构造函数可能会在几种不明显的情况下被隐式调用。这种隐式调用通常发生在对象需要被复制时，但代码中并没有明显的赋值或构造函数调用。了解这些情况对于高效和正确地管理资源非常重要。

作为函数参数传递（按值传递）

当对象作为函数参数按值传递时，会调用拷贝构造函数来创建参数的本地副本。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() {}
    MyClass(const MyClass &) {
        cout << "拷贝构造函数被隐式调用" << endl;
    }
};
void function(MyClass obj) {
    // 对 obj 的操作
}
int main() {
    MyClass myObject;
    function(myObject); // 调用 function 时，拷贝构造函数被隐式调用
    return 0;
}

从函数返回对象（按值返回）

当函数返回一个对象时，拷贝构造函数会被用于创建返回值的副本。

MyClass function() {
    MyClass tempObject;
    return tempObject; // 返回时，拷贝构造函数被隐式调用
}
int main() {
    MyClass myObject = function(); // 接收返回值时可能还会有一次拷贝（或移动）
    return 0;
}

初始化另一个对象

当用一个对象初始化另一个同类型的新对象时，会使用拷贝构造函数

int main() {
    MyClass obj1;
    MyClass obj2 = obj1; // 初始化时，拷贝构造函数被隐式调用
    return 0;
}

在所有这些情况下，如果类包含资源管理（例如，动态内存分配），那么正确地实现拷贝构造函数是非 常重要的，以确保资源的正确复制和管理，防止潜在的内存泄漏或其他问题。此外，随着 C++11 的引 入，移动语义提供了对资源的高效管理方式，可以减少这些场景中的资源复制。

禁用拷贝构造函数

禁用拷贝构造函数是一种常用的做法，尤其是在设计那些不应该被复制的类时。这可以通过将拷贝构造函数声明为 private 或使用 C++11 引入的 delete 关键字来实现。这样做的目的是防止类的对象被拷贝，从而避免可能导致的问题，如资源重复释放、无意义的资源复制等

使用 delete 关键字

可以使用 delete 关键字明确指定不允许拷贝构造

class NonCopyable {
public:
    NonCopyable() = default; // 使用默认构造函数
    // 禁用拷贝构造函数
    NonCopyable(const NonCopyable&) = delete;
    // 禁用拷贝赋值运算符
    NonCopyable& operator=(const NonCopyable&) = delete;
};
int main() {
    NonCopyable obj1;
    // NonCopyable obj2 = obj1; // 编译错误，拷贝构造函数被禁用
    return 0;
}

使用 private 声明

常见的做法是将拷贝构造函数和拷贝赋值运算符声明为 private ，并且不提供实现：

class NonCopyable {
private:
    // 将拷贝构造函数和拷贝赋值运算符设为私有
    NonCopyable(const NonCopyable&);
    NonCopyable& operator=(const NonCopyable&);
public:
    NonCopyable() {}
};
int main() {
    NonCopyable obj1;
    // NonCopyable obj2 = obj1; // 编译错误，因为无法访问私有的拷贝构造函数
    return 0;
}

在这个例子中，任何尝试拷贝 NonCopyable 类型对象的操作都会导致编译错误，因为拷贝构造函数和拷贝赋值运算符是私有的，外部代码无法访问它们。 通过这些方法，你可以确保你的类的对象不会被意外地拷贝，从而避免可能出现的资源管理相关的错误。

码农小白
关注
  • 25
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++学习之构造函数
12-26
#include class Test { private: int i; int j; int k; public : void initialize() { i=0; ... ///构造函数 t1.print(); return 0; } 使用构造函数 #include class Test { private: int i; int
⚡【C++要笑着学】(7) 默认成员函数：构造函数 | 析构函数 | 拷贝构造函数
热门推荐
⚡ 柠檬叶子团队
03-15 2万+
朋友们好啊，今天终于更新了。我是柠檬叶子C，本章将继续讲解C++中的面向对象的知识点，本篇主要讲解默认成员函数中的构造函数、析构函数和拷贝构造函数。还是和以前一样，我们将由浅入深地去讲解，以 "初学者" 的角度去探索式地学习。会一步步地推进讲解，而不是直接把枯燥的知识点倒出来，应该会有不错的阅读体验。如果觉得不错，可以 "一键三连" 支持一下博主！
C/C++编程：构造函数私有化会有什么后果
OceanStar的博客
05-12 1176
提问：假设只有一个构造方法，如果将之私有化会有什么后果 对于当前类，它是无法实例化的 对于它的子类，子类也是无法实例化的 构造函数与是否能够实例化有关 准备 对于单个类 正常情况下 #include <iostream> using namespace std; class EventDispatcher { public: void test_printf(){ std::cout << "test_printf --\r\n"; }
C++ 学习 ::【基础篇：12】：C++ 类的基本成员函数：构造函数基本的定义与调用 |（无参构造与有参构造及缺省参数式构造）
weixin_53202576的博客
06-02 1234
本期内容主要介绍了 C++ 中的 类中基本成员函数 —— 构造函数；C++ 类的基本成员函数：构造函数基本的定义与调用 |（无参构造与有参构造及缺省参数式构造）
C++精讲：构造函数
cpp_learner的博客
12-01 2503
构造函数 前言： 构造函数我是们学习c++面向对象非常重要的一门知识点，它种类繁多，相对起来比较难理解。下面是我的一些学习心得，我把它全部分好类，在附加上例子，希望你们一看就懂！ 构造函数的作用： 在创建一个新的对象时，自动调用的函数，用来进行“初始化”工作：对这个对象内部的数据成员进行初始化。 构造函数的的特点： 1.自动调用（在创建新的对象时，自动调用）； 2.构造函数的函数名和类名相同； ...
C++学习：类class中的构造函数和析构函数
qq_44148191的博客
10-27 989
C++学习 6
C/C++编程：默认构造函数
OceanStar的博客
03-18 1万+
默认构造函数 默认构造函数：是无参调用的构造函数，包括两种： 没有参数 每个参数有初始值 默认构造函数在默认初始化和值初始化中得到调用。 默认初始化：在不使用初始化器构造变量时执行的初始化。 值初始化：在以空初始化器构造对象时进行的初始化 由来 先看下面代码 代码内容很简单，定义了一个包含成员x，y的类Point。在序列的地方可以使用这个类 虽然我们并没有定义Point类的构造函数，我们依然可以定义Point类的pt对象并使用它，其原因是编译器会自动生成一个缺省的构造函数，其效果相当于 但是，
C++学习：带有默认参数值的构造函数
qq_41708281的博客
08-08 614
参考：面向对象程序设计及C++，P51。
C++拷贝构造函数、赋值学习整理：
weixin_62946182的博客
01-23 1196
拷贝构造函数作用即将一个已经存在的对象用于初始化构造新的对象，我们没有定义拷贝构造函数时，系统将自动构造拷贝构造函数：从给定对象中依次将每个非static成员拷贝到正在创建的新对象中。即分以下几种情况：
学习C++之STL：vector的构造函数
星辰大海的博客
03-11 1091
vector的构造函数有4种形式： 第1种：默认构造函数，采用模板实现类实现，实例代码如下 vector<int> v1; 执行结果是v1为空容器，没有保存任何元素，但是并不意味着v1没有分配内存 第2种：将已有的数组的区间中的元素拷贝给本身，实例代码如下 //先进行v1的赋值 for(int i=1;i<6;i++) v1.push_back(i); //将[v1.begin...
C++ 基础相关:构造函数相关话题
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-25 866
在深入探索C++的构造函数之旅开始之前，我们首先需要理解构造函数在C++编程中的核心地位和它们为何如此重要。构造函数不仅仅是一种技术或一个程序设计的工具，它更像是一扇门，通过这扇门，我们可以进入C++对象的世界。构造函数定义了对象的初始状态，确保了对象在使用前已经准备就绪。在这一章节中，我们将从多个维度深入探讨构造函数，不仅仅局限于技术层面，还会涉及到它们如何影响我们的编程思维和设计哲学。
C++构造函数深度学习
09-01
主要为大家详细介绍了C++构造函数，深度学习C++构造函数，感兴趣的小伙伴们可以参考一下
详解C++ 拷贝构造函数
08-18
主要介绍了C++ 拷贝构造函数的相关资料，文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Linux学习C语言版 LED 灯实验
qq_44219883的博客
05-10 641
大部分情况下都是使用 C 语言去编写的。只是在开始部分用汇编来初始化一下 C 语言环境，比如初始化 DDR、设置堆栈指针 SP 等等，当这些工作都做完以后就可以进入 C 语言环境，也就是运行 C 语言代码，一般都是进入 main 函数。所以我们有两部分文件要做：①、汇编文件汇编文件只是用来完成 C 语言环境搭建。②、C 语言文件C 语言文件就是完成我们的业务层代码的，其实就是我们实际例程要完成的功能。
C语言中static和volatile关键字的作用
qq_37505962的博客
05-07 189
C语言中关键字 static 与 volatile的作用
C++ STL的锁介绍
05-07 249
C++ STL的锁介绍
C++学习第二十八课：C++ 中的智能指针详解
2401_84585615的博客
05-10 858
智能指针是一种对象，它可以像常规指针一样使用，但具有自动管理内存的功能。当智能指针离开其作用域时，它会自动删除所指向的对象，从而避免内存泄漏。和。
【C语言】整数和浮点数在内存中的存储
最新发布
2303_80341387的博客
05-10 1181
其实超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题。比如：或者这样设计：或者还有其他的顺序存储，按照理论上讲，这几种都是可以的。数据在往里面存的时候，再怎样把它拿出来就行了啊！大端（存储）模式是指数据的低位字节内容保存在内存的⾼地址处，而数据的⾼位字节内容，保存在内存的低地址处。小端（存储）模式是指数据的低位字节内容保存在内存的低地址处，⽽数据的⾼位字节内容，保存在内存的⾼地址处。上述概念需要记住，方便分辨大小端。那么我们是怎么理解高位节和低位节呢？
C++ vector的使用
奇树谦的博客
05-07 300
是C++标准模板库（STL）的一部分，它允许你添加、删除、排序和搜索元素。是一个功能强大的容器，它在C++程序中被广泛使用。了解这些基本操作可以帮助你更好地利用。是一个动态数组，它提供了一种灵活的方式来存储和操作元素集合。
学习C++的构造函数
07-27
在C++中，有几种不同类型的构造函数。 首先，自定义拷贝构造函数是一种特殊的构造函数，用于创建一个新对象并将其初始化为与另一个对象相同的值。通过在类中定义一个拷贝构造函数，可以自定义如何复制对象的数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值