C++编程技巧与规范-类和对象

类和对象

1. 静态对象的探讨与全局对象的构造顺序

静态对象的探讨

类中的静态成员变量(类类型静态成员)
  • 类中静态变量的声明与定义（类中声明类外定义）
#include<iostream>
using namespace std;namespace _nmspl
{class A{public:A():m_i(5){cout << "A:A()缺省构造函数执行了" << endl;}~A(){cout << "A:~A()缺省析构函数执行了" << endl;}int m_i;};class B{public:static A m_sa; // 静态成员变量的声明};A B::m_sa; // 这是对类B静态成员变量m_sa的定义
}int main()
{_nmspl::B bobj;cout << bobj.m_sa.m_i;return 0;
}
  • 没有创建类B时
    • 类中静态成员变量即使没有被调用，也会被构造和析构 在这里插入图片描述
  • inline

    • inline关键字最初用于建议编译器尝试将一个函数体直接插入到调用该函数的地方，以减少函数调用的开销。这并不意味着编译器一定会内联这个函数，它只是对编译器的一个提示。

    • 在C++17增加新用法，

      • 内联变量
      • 在这里插入图片描述
      • 在这里插入图片描述
      • 在这里插入图片描述

    • 内联静态成员变量

      • 在这里插入图片描述

    • visual studio中改变C++标准

      • 在这里插入图片描述
        #include<iostream>
using namespace std;namespace _nmspl
{class A{public:A():m_i(5){cout << "A:A()缺省构造函数执行了" << endl;}~A(){cout << "A:~A()缺省析构函数执行了" << endl;}int m_i;};//class B//{//public://	static A m_sa; // 静态成员变量的声明//};//A B::m_sa; // 这是对类B静态成员变量m_sa的定义class B{public:inline static A m_sa; // 静态成员即声明又定义};
}
函数中的静态对象(类类型静态对象)
  • 如果函数没有被调用过，那么这个静态对象不会被构造，即使函数被调用多次，静态对象也只会被创建依次

区别于:类中静态成员变量即使没有被调用，也会被构造和析构

全局对象的构造顺序问题

  • 全局对象的构造顺序不确定的
    • 在这里插入图片描述
  • 注意不要出现构造一个全局对象，需要另外一个全局对象，因为无法确定谁先被构造
    • 出现错误在这里插入图片描述
// class1.h
#ifndef __CLASS1_H__
#define __CLASS1_H__class Class1 {
public:Class1();~Class1();
};
#endif// class2.h
#ifndef __CLASS2_H__
#define __CLASS2_H__class Class2 {
public:Class2();~Class2();
public:int m_i;
};
#endif// class1.cpp
#include<iostream>
using namespace std;
#include"Class1.h"
#include"Class2.h"extern Class2 gclass2;
Class1::Class1() 
{cout << "调用Class2中的m_i=" << gclass2.m_i << endl;cout << "Class1:构造函数()" << endl;
}
Class1::~Class1()
{cout << "Class1:析构函数()" << endl;
}// class2.cpp
#include<iostream>
using namespace std;
#include"Class2.h"Class2::Class2():m_i(5)
{cout << "Class2:构造函数()" << endl;
}
Class2::~Class2()
{cout << "Class2:析构函数()" << endl;
}// main.cpp
#include<iostream>
using namespace std;
#include"Class1.h"
#include"Class2.h"
Class1 gclass1;
Class2 gclass2;
int main()
{return 0;
}
  • 如果需要可以使用函数进行构造返回
    • 在这里插入图片描述
// class1.h
#ifndef __CLASS1_H__
#define __CLASS1_H__class Class1 {
public:Class1();~Class1();
};
#endif// class2.h
#ifndef __CLASS2_H__
#define __CLASS2_H__class Class2 {
public:Class2();~Class2();
public:int m_i;
};
#endif// class1.cpp
#include<iostream>
using namespace std;
#include"Class1.h"
#include"Class2.h"#include"func.h"extern Class2 gclass2;
Class1::Class1() 
{cout << getClass2().m_i << endl;cout << "Class1:构造函数()" << endl;
}
Class1::~Class1()
{cout << "Class1:析构函数()" << endl;
}// class2.cpp
#include<iostream>
using namespace std;
#include"Class2.h"Class2& getClass2()
{static Class2 gclass2;   // 不要在多线程中调用return gclass2;
}
Class2::Class2():m_i(5)
{cout << "Class2:构造函数()" << endl;
}
Class2::~Class2()
{cout << "Class2:析构函数()" << endl;
}
// func.h
#ifndef __FUNC_H__
#define __FUNC_H__class Class2; // 类的前置声明
Class2& getClass2();
#endif
// main.cpp
#include<iostream>
using namespace std;
#include"Class1.h"
#include"Class2.h"
Class1 gclass1;
//Class2 gclass2;
int main()
{return 0;
}

2. 拷贝构造函数和拷贝赋值运算符

拷贝构造函数和拷贝赋值运算符的书写

#include<iostream>using namespace std;namespace _nmspl 
{class A{public:A() :m_caa(0), m_cab(0) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;}//拷贝赋值运算符重载A& operator+(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}public:int m_caa;int m_cab;};
}
int main()
{
}

对象自我赋值产生的问题

#include<iostream>
#include<cstring>
using namespace std;namespace _nmspl 
{class A{public:A() :m_caa(0), m_cab(0) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;}//拷贝赋值运算符重载A& operator+(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}public:int m_caa;int m_cab;};
}namespace _nmsp2
{class A{public:A() :m_caa(0), m_cab(0),m_cap(new char[100]) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;// 注意这个是错误的，拷贝构造函数时内存还未分配，直接new即可/*if (m_cap != NULL)  {delete[] m_cap;m_cap = NULL;}*/m_cap = new char[100];memcpy(m_cap,tmpobj.m_cap,100);}//拷贝赋值运算符重载A& operator+(const A& tmpobj){if (&tmpobj == this)return *this;// 注意这个是需要进行内存释放的，因为已经调用过构造函数了if (m_cap != NULL){delete[] m_cap;m_cap = NULL;}m_cap = new char[100];strcap(m_cap, tmpobj.m_cap);m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}~A(){delete[] m_cap;			}public:int m_caa;int m_cab;char* m_cap;};
}
int main()
{
}

继承关系下的拷贝构造函数和拷贝赋值运算符的书写

  • 关键点
    • 当又子类时，一定要将父类的析构函数设置为虚函数。不然在多态时，子类的析构函数不会被调用。
    • 当父类和子类同时都有拷贝构造函数和赋值运算符重载函数时，子类一定要主动去调用父类的这两个函数。不然父类的这两个函数不会被调用。
  • 在C++中，将基类（父类）的析构函数声明为虚函数是非常重要的，特别是在涉及到多态和继承的情况下。这样做的主要原因是确保当通过基类指针删除派生类对象时，能够正确地调用派生类的析构函数，从而释放派生类中可能分配的所有资源。这有助于避免内存泄漏或其他资源管理的问题。
#include <iostream>class Base {
public:~Base() { std::cout << "Base destructor\n"; }
};class Derived : public Base {int* data;
public:Derived() { data = new int[10]; }  // 分配一些资源~Derived() { delete[] data; std::cout << "Derived destructor\n"; }
};int main() {Base* basePtr = new Derived();delete basePtr;  // 这里只调用了Base的析构函数
}

在这个例子中，Base 类的析构函数不是虚函数。当我们通过 Base* 指针删除 Derived 对象时，只有 Base 的析构函数被调用。这意味着 Derived 类中的资源（即 data 数组）没有被释放，导致了内存泄漏。

  • 当子类B为空时
    #define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstring>
using namespace std;namespace _nmspl 
{class A{public:A() :m_caa(0), m_cab(0) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;}//拷贝赋值运算符重载A& operator+(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}public:int m_caa;int m_cab;};
}namespace _nmsp2
{class A{public:A() :m_caa(0), m_cab(0),m_cap(new char[100]) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;// 注意这个是错误的，拷贝构造函数时内存还未分配，直接new即可/*if (m_cap != NULL)  {delete[] m_cap;m_cap = NULL;}*/m_cap = new char[100];memcpy(m_cap,tmpobj.m_cap,100);}//拷贝赋值运算符重载A& operator+(const A& tmpobj){if (&tmpobj == this)return *this;// 注意这个是需要进行内存释放的，因为已经调用过构造函数了if (m_cap != NULL){delete[] m_cap;m_cap = NULL;}m_cap = new char[100];memcpy(m_cap, tmpobj.m_cap,100);m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}virtual ~A(){delete[] m_cap;			}public:int m_caa;int m_cab;char* m_cap;};class B:public A{};
}
int main()
{_nmsp2::B bobj1;bobj1.m_caa = 100;bobj1.m_cab = 200;strcpy(bobj1.m_cap,"new class");_nmsp2::B bobj2 = bobj1;  // 执行类A的拷贝构造函数bobj2 = bobj1; // 执行类A的拷贝赋值运算符
}
  • 当子类B有自己的拷贝和赋值;
    #define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstring>
using namespace std;namespace _nmspl 
{class A{public:A() :m_caa(0), m_cab(0) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;}//拷贝赋值运算符重载A& operator+(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;return *this;}public:int m_caa;int m_cab;};
}namespace _nmsp2
{class A{public:A() :m_caa(0), m_cab(0),m_cap(new char[100]) {}//拷贝构造函数A(const A& tmpobj){m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;// 注意这个是错误的，拷贝构造函数时内存还未分配，直接new即可/*if (m_cap != NULL)  {delete[] m_cap;m_cap = NULL;}*/m_cap = new char[100];memcpy(m_cap,tmpobj.m_cap,100);cout << "父类的拷贝构造函数" << endl;}//拷贝赋值运算符重载A& operator+(const A& tmpobj){if (&tmpobj == this)return *this;// 注意这个是需要进行内存释放的，因为已经调用过构造函数了if (m_cap != NULL){delete[] m_cap;m_cap = NULL;}m_cap = new char[100];memcpy(m_cap, tmpobj.m_cap,100);m_caa = tmpobj.m_caa;m_cab = tmpobj.m_cab;cout << "父类的拷贝赋值运算符" << endl;return *this;}virtual ~A(){delete[] m_cap;			}public:int m_caa;int m_cab;char* m_cap;};class B:public A{public:B() = default;B(const B& b){cout << "子类的拷贝构造函数" << endl;}void operator=(const B& b){cout << "子类的拷贝赋值运算符" << endl;//return B();}};
}
int main()
{_nmsp2::B bobj1;bobj1.m_caa = 100;bobj1.m_cab = 200;strcpy(bobj1.m_cap,"new class");_nmsp2::B bobj2 = bobj1;  // 只调用子类的拷贝构造函数bobj2 = bobj1; // 只调用子类的拷贝赋值运算符
}

只调用子类的函数

  • 需要程序自己主动去调用父类的拷贝构造函数与拷贝赋值运算符函数
    class B : public A{public:B() = default;B(const B& b) : A(b){cout << "子类的拷贝构造函数" << endl;}B& operator=(const B& b){A::operator=(b);cout << "子类的拷贝赋值运算符" << endl;return *this;}};

注意：调用父类的构造函数的错误写法
B(const B& b)
{
A(b);//存在二义性，创建对象或者调用函数
cout << “子类的拷贝构造函数” << endl;
}

  • 检查内存是否释放（只有在F5才起作用）
    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
int* p = new int[10];

在这里插入图片描述

3. 类的public继承(is-a关系)及代码编写规则

  • 子类继承父类得方式-有三种：公有；受保护：私有继承
    • public代表得是一种is-a(是一种)的关系。通过这个子类产生的对象也一定是一个父类对象。
    • 人类(人类)，人类(男人)：父类表现的是一种更泛化的概念，而子类表现得是一种更特化的概念.
    • public继承关系的检验规则:能够在父类对象上做的行为也必然能在子类对象上做，每个子类对象同时也都是一个父类对象。
    • 里氏替换(利斯科夫替换)原则:任何基类出现的地方都应该可以无差别的使用子类替换.

子类遮蔽父类的普通成员函数

  • 对于public继承，不建议也不应该使用子类的普通成员函数遮蔽同名的父类的普通成员函数
  • 既然在父类中是普通成员函数，那么就代表在子类中不会有不同的行为，代表的是一种不变性。
    #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;
class Humain
{
public:void eat(){cout << "人类吃食物" << endl;}virtual ~Humain(){}
};class Man :public Humain
{
public:void eat(){cout << "男人吃面试" << endl;}
};
int main()
{Man man;man.eat(); // 调用子类的函数man.Humain::eat(); // 调用父类的成员函数
}

父类的纯虚函数接口

  • 纯虚函数，让子类继承父类的纯虚函数接口。
  • 纯虚函数
    • 拥有此函数的类变成了抽象类，抽象类不能生成该类对象
    • 任何继承该类的类，必须实现这个纯虚函数。

父类的虚函数接口

  • 虚函数让子类继承父类的虚函数接口和实现，子类也可以提供实现

为纯虚函数指定实现体

  • 为纯虚函数指定实现体
    • 强制子类必须去实现该函数
    • 让一些确实不需要单独实现该接口的子类有机会直接调用父类的该实现体

类的public继承(is-a关系)综合范例

public继承关系下的代码编写规则

4. 类与类之间的组合关系和委托关系

组合关系(复合关系-Compositon)

  • 一个类中的定义中含有其他类类型变量
has-a关系(is-part-os)
is-implemented-in-terms-of关系
  • 根据…实现…

// multimap：键可以重复
// 我们现在先去实现一个键不可以重复的map
// 继承关系
//class MyMap :public multimap<T, U> {…};

template<typename T,typename U>
class MyMap
{
public:void insert(const T& key, const U & value){if (container.find(key) != container)return;container.insert(make_pair<T, U>(key, value));}size_t size(){return container.size();}
private:multimap<T, U> container;
};
组合关系的UML图

在这里插入图片描述
在这里插入图片描述

实心菱形框 - 组合关系中的Human与Info对象具有相同的生命周期

委托关系(聚合关系：Deletation)

  • 一个类中具有指向宁外一个类的指针
    • 在这里插入图片描述

空菱形框 - 生命周期不一样

5. 类的private继承探讨

  • public继承
    class Humain
{
public:
};class Man :public Humain
{
public:
};
int main()
{Man man;Humain & human = man;   // 父类引用绑定子类对象Humain* pHUman = &man;  //父类指针指向子类对象return 0;
}
  • private继承：就不属于is-a关系了
    在这里插入图片描述
  • private继承是一种组合关系，是组合关系中的is-implemented-in-terms-of根据…实现…
  • 一般优先考虑使用组合关系，只有在一些比较特殊的情况和必要的情况下，比如牵扯一些保护的成员、私有成员、虚函数等 案例如下
  • 在这里插入图片描述

6. 不能被拷贝构造和拷贝赋值的类对象

  • 给构造函数写delete，编译器也不会自动生成默认的构造函数，需要程序员自己去写
    class A
{
public:A(const& A a) = delete;
};
int main()
{A a;  //报错return 0;
}

实现方案一：delete

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
public:A(const& A a) = delete;A& operator=(const& A a)= delete;
};
int main()
{A a;return 0;
}

实现方案二:private

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
private:A(const& A a) = delete;A& operator=(const& A a)= delete;
};
int main()
{A a;return 0;
}

但是类内还是可以访问这两个函数

实现方案三:不提供实现

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
public:A() = default;A(const A& a) ;A& operator=(const A& a);
};
int main()
{A a;A a1(a);a1 = a;return 0;
}

调用会出现链接错误

实现法案四：继承Noncopyable成员

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class Noncopyable
{
protected:Noncopyable() {};~Noncopyable() {};
private:Noncopyable(const Noncopyable& a) ;Noncopyable& operator=(const Noncopyable& a);
};
class A :private Noncopyable
{};
int main()
{A a;A a1(a);a1 = a;return 0;
}

7. 虚析构函数的内存泄露问题深谈

  • 一个类如果不是父类，建议此类的析构函数不要定义为虚析构函数。因为这样会因为虚函数表增一个虚函数表指针
  • 为什么会出现内存泄露问题
    #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class ThirdPart
{
public:ThirdPart() = default;~ThirdPart() {cout << "~ThirdPart()被调用" << endl;};
};
class A :public ThirdPart
{
public:int* m_p;A() {m_p = new int[100];}~A(){cout << "~A()被调用" << endl;delete m_p;}
};
int main()
{ThirdPart * ths = new A();delete ths;return 0;
}

不要随便public继承一个类

  • 一个类不可以被继承：final
     class ThirdPart final
{
public:ThirdPart() = default;~ThirdPart() {cout << "~ThirdPart()被调用" << endl;};
};

只有父类指针指向子类对象或者父类引用绑定到子类对象时，父类才需要虚析构函数
如果子类private或protected继承父类，那么父类指针不能指向子类对象，只能时public继承，需要父类提供虚析构函数

  • 一个函数的成员函数被声明为非public中，在main函数不能被调用

    class A 
{	~A(){cout << "~A" << endl;}
};
int main()
{A* p = new A();   delete p;  // erro:注意这里是去调用A的析构函数，而A的析构函数不能被调用return 0;
}
``

  • 下面也就好理解了

    #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class Noncopyable
{
protected:Noncopyable() {};~Noncopyable(){cout << "~Noncopyable" << endl;};
private:Noncopyable(const Noncopyable& a);Noncopyable& operator=(const Noncopyable& a);
};
class A :public Noncopyable
{	~A(){cout << "~Noncopyable" << endl;}
};
int main()
{Noncopyable* p = new A();delete p;return 0;
}

8. 类设计中的有些技巧

8.1 优先考虑为成员变量提供访问接口

class A
{
public： int m_a;
}；class A
{
public :int getA(){return m_a;}
private： int m_a;
}；

8.2 如何避免将父类的虚函数暴露给子类

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
public:void fun(){func();}virtual ~A() {}
private:virtual void func(){cout << "A::func()" << endl;}
};class B:public A
{
public:B() = default;
private:virtual void func(){cout << "B::func()" << endl;}
};
int main()
{A* p = new B();p->fun(); //B::func()return 0;
}

fun函数是func虚函数的一行通道性质的代码。非虚拟接口(Nonvirtual Interface NVI)
如果能将虚函数设置为私有，则优先考虑将其设置为私有

8.3 不要在类的构造函数和析构函数中调用虚函数

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
public:void fu(){func1_vir();}A(){func1_vir();}virtual ~A() {func2_vir();}virtual void func1_vir(){cout << "A::func1_vir()" << endl;}virtual void func2_vir(){cout << "A::func2_vir()" << endl;}
};class B:public A
{
public:B(){func1_vir();}virtual ~B(){func2_vir();}virtual void func1_vir(){cout << "B::func1_vir()" << endl;}virtual void func2_vir(){cout << "B::func2_vir()" << endl;}
};
int main()
{A* p = new B();cout << "begin_____" << endl;p->func1_vir();p->func2_vir();p->fu();cout << "end_____" << endl;delete p;return 0;
/* 输出结果
A::func1_vir()
B::func1_vir()
begin_____
B::func1_vir()
B::func2_vir()
B::func1_vir()
end_____
B::func2_vir()
A::func2_vir()*/
}

A::func1_vir() 父类中构造函数调用的虚函数是父类的虚函数
B::func1_vir() 子类中构造函数调用的虚函数是子类的虚函数
begin_____
B::func1_vir()
B::func2_vir()
B::func1_vir() 定义在父类中的非虚函数fu()中的虚函数调用的是子类的虚函数
end_____
B::func2_vir() 子类中析构函数调用的虚函数是子类的虚函数
A::func2_vir() 父类中析构函数调用的虚函数是父类的虚函数

如果在父类的构造函数中调用了一个子类的虚函数是无法做到的，因为执行到父类的构造函数时对象的子类部分还没有被构造出来
如果在父类的析构函数中调用一个子类的虚函数也是无法做到的，因为执行到父类的析构函数时对象的子类部分其实已经被销毁了
在构造函数或析构函数中，虚函数可能会失去虚函数的作用而被当作一个普通函数

8.4 析构函数的虚与非虚谈

  • 父类的析构函数不一定必须是虚函数，当父类指针指向子类或父类引用绑定子类时，父类需要写一个public修饰的析构函数，这样就可以通过父类的接口销毁子类对象，否则会导致内存泄漏
  • 用protect修饰析构函数
    • 无法创建子类对象
    • 无法让父类指针指向父类或者子类对象
  • 如果一个父类的析构函数不是虚函数，并且也不利用这个父类创建对象，也不会用到这个父类类型的指针，则应该考虑将父类的的析构函数使用protected修饰 ，增加代码安全性
  • 父类的析构函数不是虚函数，本身就暗示了不会通过父类的接口有销毁子类的对象

8.5 抽象类的模拟

  • 抽象类要求至少有一个纯虚函数
  • 抽象类：不能用来生成对象
  • 将模拟的抽象类的构造函数和拷贝构造函数都使用protected修饰
    class PVC
{
protected:PVC() {cout << "PVC()" << endl;}PVC(const PVC& pvc) {}
};
class SubPVC :public PVC
{
public:SubPVC(){cout << "SubPVC()" << endl;}
};
int main()
{PVC* p = new SubPVC();  //  YesPVC* p = new PVC();  //  errorreturn 0;
}
  • 将模拟的抽象类的析构函数设置为纯虚函数，并在类外提供实现体(大多数纯虚函数没有实现体，但是纯虚函数是个例外，为了释放资源，所以一般要有一个实现体)
    class PVC
{
protected:PVC() {}virtual ~PVC() = 0;
};
PVC::~PVC()
{}
class SubPVC :public PVC
{
public:~SubPVC() {}
};
  • 将模拟的抽象类的析构函数使用protected修饰

8.6 尽量避免隐式类型转换

  • 类型转换构造函数
    class A
{
public:A(int i){cout << "A()" << endl;}
};int main()
{A a = 5.2; // 将5构造成一个临时对象Areturn 0;
}
  • explicit
    class A
{
public:explicit A(int i){cout << "A()" << endl;}
};int main()
{//A a = 5;  // errorA a = A(5); return 0;
}

8.7 强制类对象不可以或只可以在堆上分配内存

8.7.1 强制类对象不可以在堆上分配内存
  • 重载类中的operator new和operator delete,并使用private修饰
    
class A
{
public:
private:static void* operator new(size_t size);static void operator delete(void *p);};int main()
{A* a = new A();  // errorA* a = new A[3];  // 但是却可以new数组return 0;
}
  • 再次修改
    #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;class A
{
public:
private:static void* operator new(size_t size);static void operator delete(void *p);static void* operator new[](size_t size);static void operator delete[](void* p);};int main()
{A* a = new A[3];return 0;
}
8.7.2 强制类对象只可以在堆上分配内存
  • 使用private修饰析构函数
class A
{
public:void destiry(){delete this;}
private:~A() {};  // 这样写也会导致创建在堆中的对象，不能delete。// 所以需要一个函数进行显示的调用};int main()
{A a;  // errorA* p = new A();p->destiry();return 0;
}

9. 命名空间使用的一些注意事项

  • 使用using声明命名空间的代码不要放在.h文件中 ，否则会造成命名空间污染
  • 在.cpp文件中，using声明语句放在include语句之后

10. 类定义的相互依赖与类的前向声明

  • 前向声明

    // a1.h
#ifndef __A1_H__
#define __A1_H__
//#include"a2.h"
class A2;
class A1
{
public:A2* pm;
};
#endif // !__A1_H__// a2.h
#ifndef __A2_H__
#define __A2_H__
//#include"a1.h"
class A1;class A2
{
public:A1* pm;
};
#endif // !__A1_H__

  • 有些情况下需要类的完整定义而不是前向声明

    • 在类A1的定义中加入类A2类型的对象
    • 在类A1的定义中需要知道类A2对象的大小
    • 在类A1中需要调用A2的成员函数
    #ifndef __A2_H__
#define __A2_H__
//#include"a1.h"
class A1;class A2
{
public:A1* pm;A1 pm;  // error
};
#endif // !__A1_H__

  • 类A1与类A2之间的直接1依赖.一般是避免这种设计。而是通过引入一个新类，让类A1和类A2都依赖这个新的类，从而打破两个类的之间的直接依赖

  • 解决1：

    • 引入中间层
    • 在这里插入图片描述

  • 解决2

    • 使用接口
    • 在这里插入图片描述

引用计数基础理论和实践

1. shared_ptr 实现及string存储简单说明

1.1 shared_ptr智能指针实现简单说明

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include<memory>
using namespace std;int main()
{shared_ptr<int> myp(new int(5));cout << "icount = " << myp.use_count() << endl;  // 1{shared_ptr<int> myp1(myp);cout << "icount = " << myp.use_count() << endl;// 2}shared_ptr<int> myp1(myp);cout << "icount = " << myp.use_count() << endl;// 2return 0;
}

在这里插入图片描述

1.2 string类型字符串存储方式的简单说明

  • string类型字符串存储方式的简单说明

  • 贪婪拷贝

  • 写时复制

  • 短字符优化

  • 在VS2022中(贪婪拷贝)

    int main()
{std::string str1("123");std::string str2 = str1;printf("str1的地址:%p\n", str1.c_str());printf("str2的地址:%p\n", str2.c_str());/*
str1的地址:0000000C7398F920
str2的地址:0000000C7398F960*/return 0;
}

    在这里插入图片描述

2. 通过copy-on-write方式实现的mystring类

在这里插入图片描述
在这里插入图片描述

2.1 骨架与计数设计

2.2 构造函数

2.3 拷贝构造函数

2.4 析构函数

2.5 拷贝赋值运算符

2.6 外部加锁，内部加锁，写时复制

  • 外部加锁：调用者负责，用调用者决定跨线程使用共享对象时的加锁时机
  • 内部加锁：对象将所有对自己的访问串行化，通过每个成员函数加锁的方法来实现，这样就不会在多线程中共享该对象时进行外部加锁了。

2.7 通过指针修改mystring所指字符串的内容


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<memory>class MyString
{
public:MyString(const char* tmp=""):pvalue(new stringvalue(tmp)){//point = tmp;}MyString(const MyString& tmp) :pvalue(tmp.pvalue)  // 拷贝构造函数{pvalue->refcount++;}MyString& operator=(const MyString& tmp)  // 拷贝赋值运算符重载{/*	if (&tmp == this)return *this;delete[] point;point = new char[strlen(tmp.point) + 1];strcpy(point,tmp.point);return *this;*/if (&tmp == this)return *this;//delete[] pvalue->point;--pvalue->refcount;//自己所指的引用计数减一if (pvalue->refcount == 0)delete pvalue; //把自己所指向的pvalue删除pvalue = tmp.pvalue;pvalue->refcount++;return *this;}//const char& operator[](int idx)const   // 非const 可以与const版本共存，但是都存在时都会调用非const版本的//{//	return pvalue->point[idx];//}char& operator[](int idx)  // const []{if (pvalue->refcount > 1){--pvalue->refcount;pvalue = new stringvalue(pvalue->point); // 写时复制}return pvalue->point[idx];}~MyString(){pvalue->refcount--;if (pvalue->refcount == 0)delete pvalue;}
private://char* point;struct stringvalue{size_t refcount; // 引用计数char* point;  stringvalue(const char* tmpstr){point = new char[strlen(tmpstr) + 1];strcpy(point,tmpstr);}~stringvalue(){delete[] point;}};
private:stringvalue* pvalue;
};
int main()
{return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/471112.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

边缘的检测

边缘的检测

边缘检测效果&#xff0c;是一种用于突出图像中的边缘&#xff0c;使物体的轮廓更加明显的图像处理技术&#xff0c;边缘检测的主要目的是找到图像中亮度变化显著的区域&#xff0c;这些区域通常对应于物体的边界&#xff0c;边缘检测相当于利用 Shader 代码自动给屏幕图像进行…
阅读更多...
HP G10服务器ESXI6.7告警提示ramdisk tmp已满

HP G10服务器ESXI6.7告警提示ramdisk tmp已满

物理服务器是HP G10 VCENTER内两台服务器报错提示ramdisk"tmp"已满&#xff0c;无法写入文件 登录ESXI命令行后发现两台主机的/tmp目录都没有空间了 定位到是ams-bbUsg.txt文件占用了大量的空间 1、关闭集群的DRS功能 2、迁移当前主机上面运行的所有虚拟机至其他主…
阅读更多...
深度学习中的感受野：从基础概念到多层次特征提取

深度学习中的感受野：从基础概念到多层次特征提取

在深度学习&#xff0c;特别是计算机视觉任务中&#xff0c;感受野&#xff08;Receptive Field&#xff09;是一个至关重要的概念。它指的是在神经网络中某一层的神经元在输入图像上“看到”的区域大小。感受野的大小影响了网络能捕捉的特征层级&#xff0c;从而决定了它的特征…
阅读更多...
Diffusion Policy——斯坦福机器人UMI所用的扩散策略：从原理到其编码实现(含Diff-Control、ControlNet详解)

Diffusion Policy——斯坦福机器人UMI所用的扩散策略：从原理到其编码实现(含Diff-Control、ControlNet详解)

前言 本文一开始是属于此文《UMI——斯坦福刷盘机器人&#xff1a;从手持夹持器到动作预测Diffusion Policy(含代码解读)》的第三部分&#xff0c;考虑后Diffusion Policy的重要性很高&#xff0c;加之后续还有一系列基于其的改进工作 故独立成本文&#xff0c;且写的过程中 …
阅读更多...
【数据结构与算法】第12课—数据结构之归并排序

【数据结构与算法】第12课—数据结构之归并排序

文章目录 1. 归并排序2. 计数排序3. 排序算法复杂度及稳定性分析在这里插入图片描述 1. 归并排序 分治法&#xff08;Divide and Conquer&#xff09;是一种重要的算法设计策略&#xff0c;其核心思想是将一个复杂的大问题分解为若干个小规模的子问题&#xff0c;递归地解决这些…
阅读更多...
2024 年 Apifox 和 Postman 对比介绍详细版

2024 年 Apifox 和 Postman 对比介绍详细版

Apifox VS Postman &#xff0c;当下流行的的两款 API 开发工具&#xff0c;2024 版对比&#xff01;
阅读更多...
vue请求数据报错，设置支持跨域请求，以及2种请求方法axios或者async与await

vue请求数据报错，设置支持跨域请求，以及2种请求方法axios或者async与await

设置跨域 通过vite创建的项目&#xff0c;一般会在你项目文件中自动生成一个名为vite.config文件&#xff0c;点击添加支持跨域的代码 import { defineConfig } from vite import vue from vitejs/plugin-vue// https://vitejs.dev/config/ export default defineConfig({plu…
阅读更多...
【ACM出版】第四届信号处理与通信技术国际学术会议（SPCT 2024）

【ACM出版】第四届信号处理与通信技术国际学术会议（SPCT 2024）

& 第四届信号处理与通信技术国际学术会议&#xff08;SPCT 2024&#xff09; 2024 4th International Conference on Signal Processing and Communication Technology 2024年12月27-29日 中国深圳 www.icspct.com 第四届信号处理与通信技术国际学术会议&#x…
阅读更多...
【大数据学习 | HBASE高级】rowkey的设计，hbase的预分区和压缩

【大数据学习 | HBASE高级】rowkey的设计，hbase的预分区和压缩

1. rowkey的设计 ​ RowKey可以是任意字符串&#xff0c;最大长度64KB&#xff0c;实际应用中一般为10~100bytes&#xff0c;字典顺序排序&#xff0c;rowkey的设计至关重要&#xff0c;会影响region分布&#xff0c;如果rowkey设计不合理还会出现region写热点等一系列问题。 …
阅读更多...
基于微信小程序的农场管理系统的设计与实现，LW+源码+讲解

基于微信小程序的农场管理系统的设计与实现，LW+源码+讲解

1.2 课题意义 现如今&#xff0c;信息种类变得越来越多&#xff0c;信息的容量也变得越来越大&#xff0c;这就是信息时代的标志。近些年&#xff0c;计算机科学发展得也越来越快&#xff0c;而且软件开发技术也越来越成熟&#xff0c;因此&#xff0c;在生活中的各个领域&…
阅读更多...
学习记录：js算法（九十二）：克隆图

学习记录：js算法（九十二）：克隆图

文章目录 克隆图思路一 克隆图 给你无向 连通 图中一个节点的引用&#xff0c;请你返回该图的 深拷贝&#xff08;克隆&#xff09;。 图中的每个节点都包含它的值 val&#xff08;int&#xff09; 和其邻居的列表&#xff08;list[Node]&#xff09;。 class Node {public int…
阅读更多...
大数据新视界 -- 大数据大厂之 Impala 性能飞跃：动态分区调整的策略与方法（上）（21 / 30）

大数据新视界 -- 大数据大厂之 Impala 性能飞跃：动态分区调整的策略与方法（上）（21 / 30）

&#x1f496;&#x1f496;&#x1f496;亲爱的朋友们&#xff0c;热烈欢迎你们来到 青云交的博客&#xff01;能与你们在此邂逅&#xff0c;我满心欢喜&#xff0c;深感无比荣幸。在这个瞬息万变的时代&#xff0c;我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而 我的…
阅读更多...
win11 新建一个批处理，双击查看本机的IP地址

win11 新建一个批处理，双击查看本机的IP地址

1、先上个图&#xff1a; 2、bat的代码&#xff1a; :: 获取本机 IP 地址 &#xff1a; 只显示ip echo off for /f "tokens2 delims:" %%a in (ipconfig ^| findstr /i "IP 地址") do set IP%%a echo %IP%pause 3、新建一个文件比如叫ip.bat&#xff0c;…
阅读更多...
Spring高手之路26——全方位掌握事务监听器

Spring高手之路26——全方位掌握事务监听器

文章目录 1. 什么是Spring事务监听器&#xff1f;2. 通过TransactionSynchronization 接口实现事务监听器3. 时序图&#xff1a;通过TransactionSynchronization 接口实现事务监听器4. TransactionalEventListener注解实现事务监听器5. 时序图&#xff1a;TransactionalEventLi…
阅读更多...
QQ 小程序已发布，但无法被搜索的解决方案

QQ 小程序已发布，但无法被搜索的解决方案

前言 我的 QQ 小程序在 2024 年 8 月就已经审核通过&#xff0c;上架后却一直无法被搜索到。打开后&#xff0c;再在 QQ 上下拉查看 “最近使用”&#xff0c;发现他出现一下又马上消失。 上线是按正常流程走的&#xff0c;开发、备案、审核&#xff0c;没有任何违规&#xf…
阅读更多...
MFC工控项目实例二十九主对话框调用子对话框设定参数值

MFC工控项目实例二十九主对话框调用子对话框设定参数值

在主对话框调用子对话框设定参数值&#xff0c;使用theApp变量实现。 子对话框各参数变量 CString m_strTypeName; CString m_strBrand; CString m_strRemark; double m_edit_min; double m_edit_max; double m_edit_time2; double …
阅读更多...
C语言 | Leetcode C语言题解之第556题下一个更大元素III

C语言 | Leetcode C语言题解之第556题下一个更大元素III

题目&#xff1a; 题解&#xff1a; int nextGreaterElement(int n){int x n, cnt 1;for (; x > 10 && x / 10 % 10 > x % 10; x / 10) {cnt;}x / 10;if (x 0) {return -1;}int targetDigit x % 10;int x2 n, cnt2 0;for (; x2 % 10 < targetDigit; x2…
阅读更多...
elementui el-table中给表头 el-table-column 加一个鼠标移入提示说明

elementui el-table中给表头 el-table-column 加一个鼠标移入提示说明

前言 在使用el-table 表格中有些表格的表头需要加入一些提示&#xff0c;鼠标移入则出现提示&#xff0c;非常实用&#xff0c;我是通过el-table中的el-tooltip实现的&#xff0c;以下的效果预览 代码实现 <el-table ref"multipleTable" :data"data"…
阅读更多...
阿里云通义大模型团队开源Qwen2.5-Coder：AI编程新纪元

阿里云通义大模型团队开源Qwen2.5-Coder：AI编程新纪元

&#x1f680; 11月12日&#xff0c;阿里云通义大模型团队宣布开源通义千问代码模型全系列&#xff0c;共6款Qwen2.5-Coder模型。这些模型在同等尺寸下均取得了业界最佳效果&#xff0c;其中32B尺寸的旗舰代码模型在十余项基准评测中均取得开源最佳成绩&#xff0c;成为全球最强…
阅读更多...
python 同时控制多部手机

python 同时控制多部手机

在这个智能时代，我们的手机早已成为生活和工作中不可或缺的工具。无论是管理多个社交媒体账号，还是处理多台设备上的事务，如何更高效地控制多个手机成为了每个人的痛点。 今天带来的这个的软件为你提供了一键控制多部手机的强大功能。无论是办公、娱乐，还是社交，你都能通过…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023