继承体系下的拷贝构造

已于 2024-05-04 19:07:22 修改
阅读量370 收藏 7
点赞数 5
分类专栏： C++ 文章标签： c++ CRTP
于 2024-05-04 14:33:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liugan528/article/details/138438049
版权

1. 子类永远都不会主动调用到父类的拷贝构造函数和拷贝赋值运算符

由以下示例可以看出调用子类Car的拷贝构造函数和拷贝赋值运算符的时候并不会调用父类Vehicle的拷贝构造函数和拷贝赋值运算符（Vehicle的拷贝构造函数和拷贝赋值运算符都是delete的。）。

#include <iostream>

class Vehicle{
public:
    //Vehicle() = default;

    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    //Vehicle(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}
    Vehicle(const Vehicle& vehicle) = delete;

    //Vehicle& operator=(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //    return *this;
    //}
    Vehicle& operator=(const Vehicle& vehicle) = delete;

private:
    std::string band_;
};

class Car: public Vehicle{
public:
    //Car() = default;
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called.\n";
    }

    Car(const Car& car): Vehicle("Tesla"){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    //Car(const Car& car){
    //    name_ = car.name_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}

    Car& operator=(const Car& car){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return *this;
    }
private:
    std::string name_;
};

int main(){
    //Vehicle vec1("BYD");
    //Vehicle vec2(vec1);
    //vec2 = vec1;

    std::cout << std::string(40, '-') << std::endl;
    Car car1("BYD");
    Car car2(car1);   // 调用父类的构造函数、子类的拷贝构造，(不会调用，也不需要父类的拷贝构造)
    car2 = car1;      // 调用子类的拷贝赋值运算符，（不会调用，也不需要父类的拷贝赋值运算符）

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出结果：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Vehicle ctor called.
Car::Car(const Car&)
Car& Car::operator=(const Car&)
----------------------------------------
Car dtor called.
Vehicle dtor called.
Car dtor called.
Vehicle dtor called.

1.1 应该在子类中主动调用父类的拷贝构造函数和拷贝赋值运算符

#include <iostream>

class Vehicle{
public:
    //Vehicle() = default;

    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }
    
    Vehicle(const Vehicle& vehicle){
        band_ = vehicle.band_;
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    //Vehicle(const Vehicle& vehicle) = delete;

    Vehicle& operator=(const Vehicle& vehicle){
        band_ = vehicle.band_;
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return *this;
    }
    //Vehicle& operator=(const Vehicle& vehicle) = delete;

private:
    std::string band_;
};

class Car: public Vehicle{
public:
    //Car() = default;
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called.\n";
    }

    Car(const Car& car): Vehicle(car), name_(car.name_) {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    Car& operator=(const Car& car){
        ((Vehicle*)(this))->operator=(car);
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return *this;
    }
    
private:
    std::string name_;
};

int main(){
    //Vehicle vec1("BYD");
    //Vehicle vec2(vec1);
    //vec2 = vec1;

    std::cout << std::string(40, '-') << std::endl;
    Car car1("BYD");
    Car car2(car1);   // 调用子类的拷贝构造函数，子类的拷贝构造函数会调用父类的拷贝构造函数
    car2 = car1;      // 调用子类的拷贝赋值运算符，子类的拷贝赋值运算符内部会调用父类的拷贝赋值运算符

    std::cout << std::string(40, '-') << std::endl;
}

// 输出结果：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Vehicle::Vehicle(const Vehicle&)
Car::Car(const Car&)
Vehicle& Vehicle::operator=(const Vehicle&)
Car& Car::operator=(const Car&)
----------------------------------------
Car dtor called.
Vehicle dtor called.
Car dtor called.
Vehicle dtor called.

1.2 使用copy-and-swap idiom

【吴咏炜老师的解答】这样的赋值能提供强异常安全保证，也不需要自赋值检查。但性能上不及传统的实现方式。
在以面向对象方式实现的对象里，通常不会支持赋值操作。连拷贝构造都不会直接提供——因为你不知道指针/引用指向的是不是派生类对象。
参见 C++ 核心指南里的 C.67 和 C.130 条款。
https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines

#include <iostream>
#include <string>

class Vehicle{
public:
    //Vehicle() = default;
    Vehicle(const std::string& brand):brand_(brand){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    Vehicle(const Vehicle& rhs): brand_(rhs.brand_){
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    //Vehicle(const Vehicle& vehicle) = delete;

    Vehicle& operator=(const Vehicle& rhs){
        Vehicle(rhs).swap(*this);
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return *this;
    }
    //Vehicle& operator=(const Vehicle& vehicle) = delete;

    void swap(Vehicle& rhs) noexcept {
        brand_.swap(rhs.brand_);
    }

private:
    std::string brand_;
};

class Car: public Vehicle{
public:
    //Car() = default;
    Car(const std::string& brand):Vehicle(brand){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called.\n";
    }

    Car(const Car& rhs): Vehicle(rhs), name_(rhs.name_) {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    Car& operator=(const Car& rhs){
        Car(rhs).swap(*this);

        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return *this;
    }

    void swap(Car& rhs) noexcept {
        static_cast<Vehicle&>(*this).swap(rhs);

        name_.swap(rhs.name_);
    }

private:
    std::string name_;
};

int main(){
    //Vehicle vec1("BYD");
    //Vehicle vec2(vec1);
    //vec2 = vec1;

    std::cout << std::string(40, '-') << std::endl;
    Car car1("BYD");
    Car car2(car1);
    car2 = car1;

    std::cout << std::string(40, '-') << std::endl;
}

输出结果：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Vehicle::Vehicle(const Vehicle&)
Car::Car(const Car&)
Vehicle::Vehicle(const Vehicle&)
Car::Car(const Car&)
Car dtor called.
Vehicle dtor called.
Car& Car::operator=(const Car&)
----------------------------------------
Car dtor called.
Vehicle dtor called.
Car dtor called.
Vehicle dtor called.

2. 继承体系下一般通过clone来实现对象的拷贝

#include <iostream>
#include <memory>

class Vehicle{
public:
    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    //Vehicle(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}
    Vehicle(const Vehicle& vehicle) = delete;

    //Vehicle& operator=(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //    return *this;
    //}
    Vehicle& operator=(const Vehicle& vehicle) = delete;

    virtual std::shared_ptr<Vehicle> clone() const = 0;

private:
    std::string band_;
};

class Car: public Vehicle{
public:
    //Car() = default;
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called.\n";
    }

    Car(const Car& car): Vehicle("Tesla"){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-ctor called." << std::endl;
    }

    //Car(const Car& car){
    //    name_ = car.name_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}

    Car& operator=(const Car& car){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-assignment called." << std::endl;
        return *this;
    }

    virtual std::shared_ptr<Vehicle> clone() const override{
        return std::shared_ptr<Vehicle>(new Car(*this));
    }

private:
    std::string name_;
};

int main(){
    std::cout << std::string(40, '-') << std::endl;

    Car car1("BYD");
    std::shared_ptr<Vehicle> vehicle = car1.clone();

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Vehicle ctor called.
Car::Car(const Car&), Car copy-ctor called.
----------------------------------------
Car dtor called.
Vehicle dtor called.
Car dtor called.
Vehicle dtor called.

如上述示例，利用clone对象的方式可以不用先构造出对象（通常调用拷贝构造函数）再将对象的地址赋给父类指针，而是直接使用已有对象的clone方法返回新创建对象的地址赋给父类指针。

3. 使用CRTP来实现继承体系下对象的拷贝

#include <iostream>
#include <memory>

template<typename ChildType>
class Vehicle{
public:
    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    //Vehicle(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}
    Vehicle(const Vehicle& vehicle) = delete;

    //Vehicle& operator=(const Vehicle& vehicle){
    //    band_ = vehicle.band_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //    return *this;
    //}
    Vehicle& operator=(const Vehicle& vehicle) = delete;

    virtual std::shared_ptr<Vehicle> clone() const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return std::shared_ptr<Vehicle>(new ChildType(static_cast<const ChildType &>(*this)));
    }

private:
    std::string band_;
};

class Car: public Vehicle<Car>{
public:
    //Car() = default;
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called.\n";
    }

    Car(const Car& car): Vehicle("Tesla"){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-ctor called." << std::endl;
    }

    //Car(const Car& car){
    //    name_ = car.name_;
    //    std::cout << __PRETTY_FUNCTION__ << std::endl;
    //}

    Car& operator=(const Car& car){
        name_ = car.name_;
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-assignment called." << std::endl;
        return *this;
    }

private:
    std::string name_;
};

int main(){
    std::cout << std::string(40, '-') << std::endl;

    Car car1("BYD");
    std::shared_ptr<Vehicle<Car>> vehicle = car1.clone();

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出结果：

----------------------------------------
Vehicle ctor called.
Car ctor called.
std::shared_ptr<Vehicle<ChildType> > Vehicle<ChildType>::clone() const [with ChildType = Car]
Vehicle ctor called.
Car::Car(const Car&), Car copy-ctor called.
----------------------------------------
Car dtor called.
Vehicle dtor called.
Car dtor called.
Vehicle dtor called.

4.什么是CRTP？

CRTP（Curiously Recurring Template Pattern） 奇异递归模板模式。
使用CRTP的目的是父类在编译时就可以知道子类的信息，将多态调用转为编译期绑定，节省了虚函数调用的开销。不使用CRTP时是虚函数调用，使用CRTP时在编译期利用子类作为模板参数，提早绑定子类，而不是运行时绑定。参考：Design Patterns With C++（八）CRTP（上）。

4.1 使用CRTP实现编译时多态

虚函数版本：

#include <iostream>
#include <memory>

template<typename ChildType>
class Vehicle{
public:
    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    Vehicle(const Vehicle& vehicle) = delete;

    Vehicle& operator=(const Vehicle& vehicle) = delete;

    virtual std::shared_ptr<Vehicle> clone() const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return std::shared_ptr<Vehicle>(new ChildType(static_cast<const ChildType &>(*this)));
    }

    /* 此处的drive()是通过虚函数实现的，也可以不用虚函数 */
    virtual void drive() {
        ((ChildType*)this)->drive();
    }

private:
    std::string band_;
};

class Car: public Vehicle<Car>{
public:
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called." << std::endl;
    }

    Car(const Car& car): Vehicle("Tesla"){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-ctor called." << std::endl;
    }

    Car& operator=(const Car& car){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-assignment called." << std::endl;
        return *this;
    }

    /* 此处的drive()是通过虚函数实现的，也可以不用虚函数 */
    virtual void drive() override {
        std::cout << "Driving a car.\n";
    }
};

class dummy: public Vehicle<dummy>{
public:
    dummy() = default;
    ~dummy() = default;
    dummy(const dummy&) = delete;
    dummy& operator=(const dummy&) = delete;
};

int main(){
    std::cout << std::string(40, '-') << std::endl;

    std::shared_ptr<Vehicle<Car>> vehicle(new Car("BYD"));
    vehicle->drive();

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Driving a car.
----------------------------------------
Car dtor called.
Vehicle dtor called.

非虚函数版本：

#include <iostream>
#include <memory>

template<typename ChildType>
class Vehicle{
public:
    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    Vehicle(const Vehicle& vehicle) = delete;

    Vehicle& operator=(const Vehicle& vehicle) = delete;

    virtual std::shared_ptr<Vehicle> clone() const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return std::shared_ptr<Vehicle>(new ChildType(static_cast<const ChildType &>(*this)));
    }

    /* 非虚函数，但结合CRTP可以实现编译时多态 */
    void drive() {
        ((ChildType*)this)->driveImp();
    }

private:
    std::string band_;
};

class Car: public Vehicle<Car>{
public:
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called." << std::endl;
    }

    Car(const Car& car): Vehicle("Tesla"){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-ctor called." << std::endl;
    }

    Car& operator=(const Car& car){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-assignment called." << std::endl;
        return *this;
    }

    /* 非虚函数，但结合CRTP可以实现编译时多态 */
    void driveImp() {
        std::cout << "Driving a car.\n";
    }
};

class dummy: public Vehicle<dummy>{
public:
    dummy() = default;
    ~dummy() = default;
    dummy(const dummy&) = delete;
    dummy& operator=(const dummy&) = delete;
};

int main(){
    std::cout << std::string(40, '-') << std::endl;

    std::shared_ptr<Vehicle<Car>> vehicle(new Car("BYD"));
    vehicle->drive();

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Driving a car.
----------------------------------------
Car dtor called.
Vehicle dtor called.

4.2 使用虚函数实现运行时多态

#include <iostream>
#include <memory>

template<typename ChildType>
class Vehicle{
public:
    Vehicle(const std::string& band):band_(band){
        std::cout << "Vehicle ctor called.\n";
    }

    virtual ~Vehicle(){
        std::cout << "Vehicle dtor called.\n";
    }

    Vehicle(const Vehicle& vehicle) = delete;

    Vehicle& operator=(const Vehicle& vehicle) = delete;

    virtual std::shared_ptr<Vehicle> clone() const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return std::shared_ptr<Vehicle>(new ChildType(static_cast<const ChildType &>(*this)));
    }

    /* 虚函数，实现运行时多态 */
    virtual void drive() = 0;

private:
    std::string band_;
};

class Car: public Vehicle<Car>{
public:
    Car(const std::string& band):Vehicle(band){
        std::cout << "Car ctor called.\n";
    }
    ~Car() {
        std::cout << "Car dtor called." << std::endl;
    }

    Car(const Car& car): Vehicle("Tesla"){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-ctor called." << std::endl;
    }

    Car& operator=(const Car& car){
        std::cout << __PRETTY_FUNCTION__ << ", Car copy-assignment called." << std::endl;
        return *this;
    }

    /* 虚函数，实现运行时多态 */
    virtual void drive() override {
        std::cout << "Driving a car.\n";
    }
};

class dummy: public Vehicle<dummy>{
public:
    dummy() = default;
    ~dummy() = default;
    dummy(const dummy&) = delete;
    dummy& operator=(const dummy&) = delete;
};

int main(){
    std::cout << std::string(40, '-') << std::endl;

    std::shared_ptr<Vehicle<Car>> vehicle(new Car("BYD"));
    vehicle->drive();

    std::cout << std::string(40, '-') << std::endl;

    return 0;
}

输出：

----------------------------------------
Vehicle ctor called.
Car ctor called.
Driving a car.
----------------------------------------
Car dtor called.
Vehicle dtor called.
GarryLau
关注
专栏目录
C++类继承基础5——构造函数与拷贝控制
2301_80224556的博客
03-30 831
{public: // 默认情况下，基类的默认构造函数初始化对象的基类部分// 要想使用拷贝或移动构造函数，我们必须在构造函数初始值列表中// 显式地调用该构造函数D(const D& d): Base(d) // 拷贝基类成员/*D的成员的初始值*/{/*...*/}D(D&& d): Base (std::move (d)) //移动基类成员/* D的成员的初始值*/{}初始值Base(d)将一个D对象传递给基类构造函数。
C++拷贝构造函数
程序人生
08-11 1278
定义 拷贝构造函数（copy constructor），又称复制构造函数，是在基于同一个类的其他对象进行构造的时候（赋值初始化、参数传递、返回值）被编译器调用的一种特殊构造函数。假设有一个类类型为T，拷贝构造函数的第一个形参必须是该类类型的引用，（即T&）也可以用cv限定符来修饰（const T&、volatile T&或const volatile T&），也可...
继承关系中的拷贝构造函数和赋值操作重载函数分析
木子皿--啥都不会的菜鸟
04-03 511
文章目录1 继承关系中的拷贝构造函数和赋值操作重载函数分析 1 继承关系中的拷贝构造函数和赋值操作重载函数分析 在继承关系中，如果子类未实现拷贝构造函数，那么在子类进行拷贝构造操作时，会直接调用父类的拷贝构造函数，如果父类的拷贝构造函数是私有的，则会编译失败。我们有时候也会故意把父类的拷贝构造函数设置为私有的，从而禁止子类的拷贝构造操作。 在继承关系中，如果子类未实现赋值操作重载函数，那么在子类进...
简要谈谈C++继承中派生类的 构造 拷贝 赋值 析构的调用问题
呋喃吖的博客
04-07 1321
文章目录继承体系派生类的特殊函数调用规则演示验证派生类调用父类的构造和赋值运算符总结： 继承体系派生类的特殊函数调用规则 C++中有如下规则： 基类有默认构造函数，派生类假如不显示调用基类的默认构造函数，那么派生类的构造函数会自动调用基类的默认构造函数；假如基类没有默认构造函数，那么派生类必须显示的去调用基类的其他构造函数； 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。假如派生类不调用基类的拷贝构造就会报错 派生类的operator=必须要调用基类的operator=完成基
父类子类的拷贝构造与赋值
diaozhiwa5526的博客
09-08 800
1. 本文目的：理清在各种继承时，构造函数、复制构造函数、赋值操作符、析构函数的执行顺序和执行内容。 2. 说明：虽然复制构造函数属于构造函数的一种，有共同的地方，但是也具有一定的特殊性，所以在总结它的性质时将它单独列出来了。 3. 单继承、多继承、虚继承，既然都属于继承，那么虽然有一定的区别，但还是相同点比较多。如果放在一块讲，但为了将内容制作成递进的，就分开了，对相同点进行...
名字查找、拷贝控制操作与继承体系
最新发布
sengyongan的博客
08-25 917
如果一个类没有合成拷贝控制操作，派生类不会继承基类的函数，而是编译器会为派生类合成默认的版本。除了虚函数的覆盖外，尽量不要定义同名的普通成员和函数。
Modern C++ std::variant的继承体系
老宅的虚拟空间
02-23 4384
理解std::variant的继承体系
继承体系下虚函数表的初始化
白鼠的学习足迹
03-20 1162
构造函数和析构函数里面可以调用虚函数吗？写个例子测试一下就知道这并没什么问题，程序也许可能按预期正常执行，但是语法上通过的东西，未必真的就make sense。《深度探索C++对象模型》一书中分析了对象的创建过程，括构造虚函数表的时机。
C++日记——Day20：继承的构造函数、多重继承、虚继承
weixin_38278993的博客
03-01 631
继承的构造函数 一个类只继承其直接基类（父类）的构造函数。默认、拷贝、移动构造函数是不能被继承的。 class A{ public: A(); }; class B : public A{ public: using A::A; //遇到这条语句，编译器会把积累的每个构造函数，都会生成一个与之对应的派生类的构造函数。 } 使用 using A::A; 就是让某个名字在当前...
C++类 --- 继承的构造函数、多重继承、虚继承
平凡
04-10 1101
一、继承 继承性是面向对象程序设计的第二大特性，它允许在既有类的基础上创建新类，新类可以继承既有类的数据成员和成员函数，可以添加自己特有的数据成员和成员函数，还可以对既有类中的成员函数重新定义。利用类的继承和派生实现了更高层次的代码可重用性，符合现代软件开发的思想。 C++语言同时支持单一继承和多重继承。单一继承是指派生类只从一个基类继承而来；相应的，多重继承指派生类同时从两个或更多的基类继承...
继承体系中的拷贝控制：C++拷贝构造函数与虚函数的交响曲
[继承体系中的拷贝控制：C++拷贝构造函数与虚函数的交响曲](https://t4tutorials.com/wp-content/uploads/Assignment-Operator-Overloading-in-C.webp) # 1. 继承体系中的拷贝控制基础 在C++的面向对象编程范式中，...
面向对象设计高级教程：拷贝构造函数的继承、多态与拷贝控制
[面向对象设计高级教程：拷贝构造函数的继承、多态与拷贝控制](https://d8it4huxumps7.cloudfront.net/uploads/images/65fd3cd64b4ef_2.jpg?d=2000x2000) # 1. 面向对象设计基础回顾 面向对象设计（Object-Oriented...
C++面向对象编程：拷贝构造函数解析
7. 拷贝行为与深浅拷贝在多态基类中的应用：在继承体系中，基类的拷贝构造函数需要考虑如何正确处理派生类的数据，以确保多态性的正确性。 何洁月教授的C++课程涵盖了从基础知识到高级特性的广泛内容，包括C++语言...
图片保存为YUV格式
liugan528的博客
10-24 9300
保存为NV12格式的yuv420,yyyuvuvuv #include &amp;amp;amp;lt;string&amp;amp;amp;gt; #include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; #include &amp;amp;amp;lt;opencv2/highgui/highgui.hpp&amp;amp;amp;gt; #include &amp;amp;amp;lt;opencv2/i
std::recursive_mutex使用示例
liugan528的博客
02-25 1827
std::recursive_mutex的行为几乎和std::mutex一致，区别在于已经获得了一个递归互斥体所有权的线程允许在同一个互斥体上再次调用loci()和try_lock()。调用线程调用unlock()方法的次数应该等于获得这个递归互斥体锁的次数。 #include <iostream> #include <string> #include <mutex> #include <thread> std::recursive_mutex mu; /
四万字长文说operator new & operator delete
liugan528的博客
07-03 1601
关于operator new & operator delete搞懂这一篇，对绝大多数人的C++生涯足够用了吧......
decltype用法介绍
liugan528的博客
06-20 1522
想从表达式推断出要定义的变量的类型，但不想计算表达式的值，此时可以使用decltype
API Design for C++之Pimpl设计模式
liugan528的博客
03-14 1149
创建API的主要原因是隐藏所有的实现细节，以免将来修改API对已有客户造成影响。任何内部实现细节（那些很可能变更的部分）必须对该API的客户隐藏。主要有两种技巧可以达到此目标：物理隐藏和逻辑隐藏。 物理隐藏：不让用户获得私有源代码； 逻辑隐藏：使用语言特性限制用户访问API的某些元素。 物理隐藏 物理隐藏表示将内部实现细节（.cpp）与公共接口（.h）分离，存储在不同的文件...
Caffe-classification
liugan528的博客
07-28 919
常用的东西还是记下来，省的每次用的时候都要从头捋一遍。 本文是对用caffe做classification的inference流程的梳理。 首先介绍做classification的类 /* Pair (label, confidence) representing a prediction. */ /* 保存predict的结果：标签 + 概率得分 */ typedef std::pair&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值