static+单例模式+类的复合继承

汇编语言

汇编语言是最靠谱的验证“编程语言相关知识点”正确性的方式

汇编语言与机器语言一一对应,每一条机器语言都有与之对应的汇编指令

机器语言是计算机使用的语言,它是一串二进制数字

  • 汇编语言可以通过汇编得到机器语言
  • 机器语言可以通过反汇编得到汇编语言

一:new和delete的编译器转化

​ 有一个复数类:class complex { public: complex(double a,double b); private: double real; double imag; };

new

则:complex* pc=new complex(1,2);

new得到的内存都是堆内存,需要通过delete释放内存空间

因为程序结束后,指针pc失效了,但是pc指向的内存需要人工回收

编译器对new进行以下的操作:

  1. 首先进行内存分配
void* mem=operator new(sizeof(complex));

operator new是c++库的一个函数,内部调用c语言使用的malloc

  1. 其次对指针类型转化
pc=static_cast<complex*>(mem)

把pc的类型从void转换成complex

  1. 调用构造函数
pc->complex::complex(1,2);

其实构造函数有一个默认参数:*this,这个参数传入的就是 *pc

delete

delete pc;

把上文在堆内存分配的pc申请的内存主动回收

编译器所做的工作:

  1. 调用析构函数
complex::~complex(pc);
  1. 释放内存
operator delete(pc)

operator delete函数在内部调用free()完成释放内存

总结:

new是先申请内存,再调用构造函数

delete是先调用析构函数,再释放内存

new分配的内存必须是16的倍数,不是需要填充到最近的16倍数

删除数组用delete[]

String* p=new String[3];//指针数组
delete[] p;

如果不加[],delete确实会将整个申请空间释放,但是:

指针对象可能自己申请了空间,这个空间必须靠自己的析构函数去释放

所以创建了指针数组必须对每一个对象都进行内存释放,使用delete []去多次调用析构函数

二:复习String类

class String{
public:
    // 构造函数--最好用inline提高效率
    inline String(const char *str = 0){
        if (str == 0){
            data = new char[1];
            data[0] = '\0';//*data='\0'
        }
        else{
            data = new char[strlen(str) + 1];
            strcpy(data, str);//目的,源头
        }
    }
    // 拷贝构造
    String(const String &str){
        data = new char[strlen(str.data) + 1];
        strcpy(data, str.data);
    }
    // 赋值构造---返回值本来就存在不,是在函数内创建,用&
    String &operator=(const String &str){
        // 不可以自我赋值
        if (this == &str)//指针地址相同
            return *this;
        //赋值是接收端本来就存在,所以需要清除原来内容
        delete[] data;
        data = new char[strlen(str.data) + 1];
        strcpy(data, str.data);
        return *this;//有返回值可以连串赋值:a=b=c
    }
    // 析构函数
    inline ~String(){
        delete[] data;
    }
    //输入输出辅助函数
    char *get_data() const { return data; }
private:
    char *data; // 动态分配字符指针
};

最需要注意的就是赋值构造

  1. 首先考虑返回值和传入参数:
  • 传入参数:类对象的引用

  • 返回值:类对象,由于=右边是提前存在的,用&

String & operator=(const String &str)

retutn *this;

  1. 其次注意一定要先释放目标端(=左边)的所有内容然后重新分配空间
        delete[] data;
        data = new char[strlen(str.data) + 1];
  1. 最后注意自我赋值,也就是a=b中,a和b的字符数组指针不可以相同
       if (this == &str)//指针地址相同
            return *this;

this是指针,&str是str的地址,两者不能相同

//输入输出辅助函数
    char *get_data() const { return data; }
//定义:String的输出
ostream& operator<<(ostream& os,String s){
    os << s.get_data();//接收端是字符指针
    return os;
}

注意:os<<字符指针

所以需要定义返回字符指针的私有函数,注意不改变该值,所以加上const

三:拷贝构造函数

浅拷贝

class Rect{
public:
    Rect() { p = new int(100); }
    ~Rect() {
        cout << "析构函数" << endl;
        if(p){
            delete p;
        }
    }
    void setp(int x) { *p = x; }
    int getp() const { return *p; }
private:
    int *p;
};
int main(){
    Rect a;
    Rect b(a);
    b.setp(920);
    cout << a.getp() << "," << b.getp() << endl;
    b.setp(320);
    cout << a.getp() << "," << b.getp() << endl;
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
一个改变,其他也改变,这是因为两个指针指向同一内容,这是浅拷贝

 Rect a;
 Rect b(a);
 a.~Rect();
 b.getp();

一个对象析构后,其他对象无内容

在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝

深拷贝

class Rect{
public:
    Rect() { p = new int(100); }
    Rect(const Rect& r) {
        p = new int[1];
        *p = *(r.p);
    }
    ~Rect() {
        cout << "析构函数" << endl;
        if(p){
            delete p;
        }
    }
    void setp(int x) { *p = x; }
    int getp() const { return *p; }
private:
    int *p;
};
int main(){
    Rect a;
    Rect b(a);// Rect b=a;
    a.setp(200);
    cout << a.getp() << "," << b.getp() << endl;
    a.~Rect();
    b.setp(100);
    cout << b.getp() << endl;
}

在这里插入图片描述

p = new int(100);----赋值100

p = new int[1];----分配一个内存空间

小结

拷贝有两种:深拷贝,浅拷贝。

  • 当出现类的等号赋值时,会调用拷贝函数,在未定义显示拷贝构造函数的情况下,系统会调用默认的拷贝函数——即浅拷贝,它能够完成成员的一一复制。

当数据成员中没有指针时,浅拷贝是可行的

当数据成员中有指针时,如果采用简单的浅拷贝,则两类中的两个指针将指向同一个地址,当对象快结束时,会调用两次析构函数,而导致指针悬挂现象。所以这时必须采用深拷贝。

四:static

static修饰函数中变量或者类中的变量

​ 当变量被声明为静态时,会在内存的静态变量区为其分配空间,变量值会存活在程序的生命周期内。

也就是函数内定义的静态变量只会初始化一次,而且每次调用后改变的值会影响下一次的结果

int test(){
    static int i = 0;//在函数test中定义静态变量i
    i++;
    return i;
}
int main(){
    for (int i = 0; i < 5;i++)
        cout << test() << " ";
    return 0;
}

运行结果是:1 2 3 4 5

上一次调用中的变量值将被带到下一个函数调用中

类中的静态变量仅在单独的静态存储中分配空间时初始化一次,类中的静态变量由类对象共享

class demo{
public:
    static int i;//在demo中定义静态变量
    static char c;
    demo(){}
};
/*静态变量初始化必须在类外实现*/
int  demo::i=100;
char demo::c = 'a';

类的静态变量为类所有,所以不可以用构造函数来初始化或者在类内直接初始化

类的静态变量只能由用户使用类名::静态变量名显式初始化

必须在类外声明类内静态变量—让编译器知道类中存在静态变量

一个类改变了值,其他类都会受影响

int main(){
    demo aa;
    demo bb;
    aa.c = '*';
    bb.i = 400;
    cout <<aa.c<<","<<bb.c<<endl;
    cout <<aa.i<<","<<bb.i<<endl;
    cout << demo::i << "," << demo::c << endl;
    return 0;
}

类中静态变量访问,可以用对象名.或者类型::

运行结果:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

static修饰的类函数只能访问静态变量

静态成员函数只允许访问类的静态数据成员或其他静态成员函数不能访问类的非静态数据成员或成员函数。

class demo{
public: 
    demo(){}
    static void get_Info(){
        cout << i << "," << c << endl;
    }
private:
    static int i;//在demo中定义静态变量
    static char c;
};
/*静态变量初始化必须在类外实现*/
int  demo::i=100;
char demo::c = 'a';
int main(){
    demo aa;
    demo bb;
    aa.get_Info();
    bb.get_Info();
    //更建议使用
    demo::get_Info();
    return 0;
}

静态函数的访问可以用函数名调用,或者类名作用域调用

static修饰类成员对象

静态类对象:就像变量一样,声明为静态的对象也具有直到程序生命周期为止的作用域

#include <iostream>
#include <cstring>
using namespace std;
class demo{
public:
    demo(string s):s(s) { cout << "construct fun " <<s<<endl; }
    ~demo() { cout << "delete fun " <<s<< endl; }
private:
    string s;
};
int main(){
    int x = 1;
    if(x==1){
    static demo bb("bb");
    }
    if(x==1){
    demo aa("aa");
    }
    return 0;
}

输出结果:

construct fun bb
construct fun aa
delete fun aa
delete fun bb

发现aa对象在{}结束后就调用析构函数,但是static对象bb直到程序结束才调用析构函数

stactic内存

class complex{
public:
    complex(double re):re(re) {}
    double real() const { return re; }
private:
    double re;
};
int main(){
    complex c1(2.3), c2(3.2), c3(4.6);
    cout<<c1.real()<<endl;    
    cout<<c2.real()<<endl;
    cout<<c3.real()<<endl;    
}

其实在执行:c.real()时候:编译器的形式为:

    cout<<complex::real(&c1)<<endl;    
    cout<<complex::real(&c2)<<endl;
    cout<<complex::real(&c3)<<endl; 

也就是说编译器默认有一个参数是对象的地址,这个也就是this指针

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 静态数据只有一份所有类公用
  • 非静态函数只有一份,但是每个对象都有自己的数据内存,所以只能通过this指针来找到相应数据存储区域

静态函数没有this指针

class Account{
public:
 static double m_rate;//静态变量定义
 static void set_rate(const double &x) { m_rate = x; }
};
double Account::m_rate;//静态变量声明,可以不初始化
int main(){
 Account::set_rate(9.8);
 cout << Account::m_rate << endl;
}

静态变量必须在类外有声明

五:单例模式

单例模式具有如下特点:

  • 一个类只有一个实例化对象
  • 全局可以使用

为了保证类的对象只有一个:

私有的构造函数, 拷贝构造函数,以及operator=都必须是类的私有成员

建立一个公有函数:

该公有的静态成员函数,用来构造这个类唯一的实例对象,并返回

class single{
public:
    //返回静态成员,所有用static,对象存在返回值用&
    static single& getInstance(){
        return tar;
    }
    void print(){
        cout << "success!" << endl;
    }
private:
    //三个构造函数
    single(){}
    single(const single& x){}
    single &operator=(const single &x) { return *this; }
    //静态类对象
    static single tar;
};
single single::tar;//静态成员声明
int main(){
    single::getInstance().print();
}

函数的调用:single::getInstance()

静态成员必须类外声明一下

class single{
public:
 //...
 static single& getInstance();
 //...

private:
 //...
 static single tar;
};
/*返回值   类名::静态变量*/
single single::tar;//静态成员声明

这个方式直接创建了类对象,如果不需要使用会造成资源浪费,最好是:使用时创建

静态成员函数内的静态变量可以不类外声明

class single{
public:
    //返回静态成员,所有用static,对象存在返回值用&
    static single& getInstance();
    
    void print(){
        cout << "ok!" << endl;
    }
private:
    //三个构造函数
    single(){}
    single(const single& x){}
    single &operator=(const single &x) { return *this; }
};
single& single::getInstance() {
     //在调用时候创建
     static single tar;
     return tar;
};
int main(){
    single::getInstance().print();
}

上述其实对应类单例模式的两种类型:

根据单例的创建时间,可以分为饿汉模式懒汉模式

懒汉模式: 当你的应用程序在需要调用返回类对象()方法的时候才创建实例化的对象,类似于懒加载

​ 这种方式的好处在于,有一些单例模式的实例,可能在整个进程的声明周期内可能不一定用到。那么这种懒汉模式就省去了不必要的资源创建过程。

饿汉模式一般的实现方式为:在进程或者模块加载的时候就会创建全局的实例。

单例模式释放资源

class signlePattern{
public:
    //函数对外接口
    static signlePattern* getInstance(){
        /*加上一句判断*/
        if(point==NULL){
            point = new signlePattern();
        }
        return point;
    }
    //析构私有成员函数
    static void releaseSource(){
        if(point){
            delete point;
            point = NULL;
        }
        cout << "finish" << endl;
    }
    void test() {
        cout << "has called!" << endl;
    }

private:
    //三个函数
    signlePattern(){}
    signlePattern(const signlePattern& x){}
    signlePattern &operator=(const signlePattern &x) { return *this; }
    //静态成员对象--提前创建
    static signlePattern *point;
};
//静态独享成员声明
//创建对象
signlePattern *signlePattern::point = new signlePattern;
int main(){
    signlePattern::getInstance()->test();
    signlePattern::releaseSource();
}

六:模板

类模板

class complex{
public:
    complex(T r=0,T i=0):re(r),im(i){};
    T real() const { return re; }
    T imag() const { return im; }
private:
    T re, im;
};
int main(){
    complex<int> c1(3, 6);
    complex<double> c2(1.2, 3.4);
    cout << c1.real()<< "," << c1.imag() << endl;
    cout << c2.real() << "," << c2.imag() << endl;
}

必须在定义时候声明模板类型

 complex<int> c1(3, 6);
 complex<double> c2(1.2, 3.4);

这个参数从编译角度就是把所有T换成声明类型,存在代码浪费

函数模板

class cmp{
public:
    cmp(int h=0,int w=0):h(h),w(w){};
    //重载运算符<
    bool operator<(const cmp& x) const{
        return h + w < x.h + x.w;
    }
    void getInfo(){
        cout << h << "," << w << endl;
    }
private:
    int h,w;
};
//函数模板
template<typename T>
const T& Min(const T& a,const T& b){
    return a < b ? a : b;
}
int main(){
    cmp a(3, 2);
    cmp b(2, 1);
    cmp c= Min(a, b);
    c.getInfo();
}

函数模板不需要指定类型,编译器会通过传入参数自动推导

七:面向对象编程

1:复合关系:composition

类中有类—has a

在一个类里内嵌了其他类的对象作为成员的情况,它们之间的关系是一种包含与被包含的关系。

简单说,一个类中有若干数据成员是其他类的对象。

列子:自定义一个队列类,类中存在一个双端队列成员,然后利用deque的几个函数完成普通队列功能

#include <queue>
using namespace std;
template<class T>
class MYqueue{
private:
    deque<T> dq;
public:
    void push(const T &x) { dq.push_back(x); }
    void pop() { dq.pop_front(); }
    int size() const { return dq.size(); }
    T &front() { return dq.front(); }
    T &back() { return dq.back(); }
};

主函数:

int main(){
 MYqueue<int> mq;
 for (int i = 1; i <= 5;i++)
     mq.push(i*100);
 cout << mq.size() << endl;
 cout << mq.front() << "," << mq.back() << endl;
 mq.pop();
 cout << mq.front() << "," << mq.back() << endl;
 mq.pop();
 cout << mq.front() << "," << mq.back() << endl;
}

输出结果:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

内存角度

既然是包含关系,那么大的字节数是它包含的类的字节数加上自己的成员

点和距离例子

点类

class point {
public:
    //构造函数
    point(int x, int y) : x(x), y(y) { cout << "point构造函数" << endl; }
    //拷贝构造
    point(const point& tmp) :x(tmp.x), y(tmp.y) {
        cout << "point拷贝构造函数" << endl;
    }
    //返回成员
    int getX() const { return x; }
    int getY() const { return y; }
private:
    int x, y;
};

距离类

class Distance {
public:
    //构造函数
    Distance(point, point);
    //返回dist
    double getDist() const { return dist; }

private:
    point a, b;
    double dist;
};
Distance::Distance(point a, point b) :a(a), b(b) {
    cout << "distance构造函数" << endl;
    double x = double(a.getX() - b.getX());
    double y = double(a.getY() - b.getY());
    dist = sqrt(x * x + y * y);
}

主程序:

int main(){
    point aa(0, 3);
    point bb(4, 0);
    Distance cc(aa, bb);
    cout << cc.getDist() << endl;
}

运行结果:

在这里插入图片描述


Distance(point a, point b) :a(a), b(b) {}

首先两个参数的传入调用了两次拷贝构造函数

然后把参数赋值给类的内部成员进行初始化又调用了两次拷贝构造函数

所以:一共四次调用了拷贝构造函数

还可以调用内联函数的普通函数


Distance(int,int,int,int);//声明

point(int x, int y) : x(x), y(y) { cout << "point构造函数" << endl; }
Distance::Distance(int aa,int bb,int cc,int dd) :a(aa,bb), b(cc,dd){
 cout << "distance构造函数" << endl;
 double x = double(a.getX() - b.getX());
 double y = double(a.getY() - b.getY());
 dist = sqrt(x * x + y * y);
}

运行结果:

point构造函数
point构造函数
distance构造函数

三角锥和三角形
class triangle{
public:
    triangle(int a,int b):a(a),b(b){}
    triangle(const triangle& x):a(x.a),b(x.b){}
    double square() const { return (1.0 / 2) * a * b; }
private:
    int a, b;
};
class triPyramid{
public:
    triPyramid(int a,int b,int h):t(a,b),h(h){}
    triPyramid(triangle t,int h):t(t),h(h){}
    double tiji() const { return (1.0) / 3 * t.square() * h; }

private:
    triangle t;
    int h;
};
int main(){
    triangle aa(2, 3);
    triPyramid m(aa, 6);//triPyramid(triangle t,int h)
    triPyramid n(2, 4, 6);//triPyramid(int a,int b,int h)
    cout << aa.square() << endl;
    cout << m.tiji()<<","<<n.tiji()<<endl;
}
构造函数和析构函数的顺序

class A{};

class B{ private:A a};

  • 构造由内而外:(套娃)

    B首先调用的是A的默认的构造函数,然后再执行自己的构造函数

  • 析构由外而内:(打碎套娃)

    B先执行自己,然后再调用A对象的析构函数

class point {
public:
    //构造函数
    point(int x, int y) : x(x), y(y) { cout << "point构造函数" << endl; }
    //拷贝构造
    point(const point& tmp) :x(tmp.x), y(tmp.y) {
        cout << "point拷贝构造函数" << endl;
    }
   //析构函数
    ~point() { cout << "point析构函数" << endl; }
private:
    int x, y;
};
class Distance {
public:
    Distance(int aa, int bb, int cc, int dd) :a(aa, bb), b(cc, dd) {
        cout << "distance构造函数" << endl;
    }
    ~Distance() {
        cout << "Distance析构函数" << endl;
    }
private:
    point a, b;
};
int main() {
    Distance cc(0,3,4,0);
}

在这里插入图片描述

class A{
public:
    A(int x) : x(x) { cout << "A构造函数" << endl; }
    ~A() { cout << "A析构函数" << endl; }
    void show() { cout << x << endl; }
private:
    int x;
};
class B{
public:
   B(int a,int b,int c):a(a),b(b),y(c){
       cout << "B构造函数" << endl;
   }
   ~B() { cout << "B析构函数" << endl; }
   A geta() const { return a; }
   A getb() const { return b; }
   void show() { cout << y << endl; }
   private:
   A a, b;
   int y;
};
int main(){
    B x(10, 20, 30);
    x.geta().show();
    x.getb().show();
    x.show();
}

在这里插入图片描述
注意:

10
A析构函数
20
A析构函数

这里:

x.geta().show();等价于:A a(10) ; a.show();

隐藏了声明类A的对象,因为由于包含的原因,类B已经有类A的对象的声明了


A& geta()  { return a; }
A& getb()  { return b; }
//-----
A* geta()  { return &a; }
A* getb()  { return &b; }
 B x(10, 20, 30);
 x.geta()->show();
 x.getb()->show();

在这里插入图片描述

传入引用或者指针就是类B自己的对象了

2:委托 composition by reference

说白了就是:一个类存在另一个类的指针

例子:

  • 为狗类设一个主人类的对象指针
  • 为主人类设一个狗类的对象指针数组
class CDog;
class CMaster // 主人类
{
    CDog  * pDogs[10]; // 狗类的对象指针数组
};

class CDog  // 狗类
{
    CMaster * pm;   // 主人类的对象指针
};

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
如果不用指针对象,生成 A 对象的同时也会构造 B 对象。

也就是说用指针对象不会提前进行构造

class Car
{
    Engine engine; // 成员对象
    Wing * wing;   // 成员指针对象
};

定义一辆汽车,所有的汽车都有 engine,但不一定都有 wing,所以wing 只占一个指针

class handleImpl{
public:
   void notify(){
       cout <<"hello"<< endl;
   }
};
class handle{
public:
   void notify(){
       p->notify();
   }
private:
    handleImpl *p;
};
int main(){
    handle *myhandle = new handle();
    myhandle->notify();
    return 0;
}

handle类包含handleImpl类的指针,handle类的notify()只是一个接口,真正的实现是:handleImpl类的notify()

void notify(){ p->notify(); }

类对象和类指针
  • 类对象: 类名 a;在定义之后就已经为a这个对象分配了内存,且为内存栈,是个局部的临时变量
  • 类指针: 类名 *b = new 类名();在定义*b的时候并没有分配内存,只有执行new后才会分配内存,且为内存堆,是个永久变量,除非你释放它。

3:继承Inheritance

is a关系

子类继承父类的成员还有自己的新成员

继承最有价值的部分是"虚函数"

  • 构造函数由内而外(先子类后父类)

    先调用父类的默认构造函数,然后调用子类成员的构造函数。

    Derived::Derived(...):Base(..){ ...}
    
  • 析构函数由外而内(先父类再子类)

    先调用子类成员的析构函数 ,最后调用父类的构造函数。

    Derived::~Derived() { ..., ~Base(); }
    

注意----析构函数要想保证先子类析构,后父类析构,那么:父类的析构函数必须是virtual

例子:

class doucument{
public:
    doucument(const char *s){
        name = new char[strlen(s) + 1];
        strcpy(name, s);
    }
    doucument(const doucument &s){
        name = new char[strlen(s.name) + 1];
        strcpy(name, s.name);
    }
    void showName() { cout << name << endl; }
private:
    char *name;
};
class Book:public doucument{
public:
    Book(const char* name,double p):doucument(name),price(p){}
    Book(const doucument& x,double p):doucument(x),price(p){}
    void show() {
        showName();
        cout << price<< endl; }
private:
    double price;
};
int main()
{
    doucument mm("hello");
    Book n1("good", 19.9);
    Book n2(mm, 29.9);
    n1.show();
    n1.show();
}

Book(const char* name,double p):doucument(name),price(p){}
Book(const doucument& x,double p):doucument(x),price(p){}

注意:基类的构造函数名称要指明

基类的共有函数可以被派生类直接调用

void show() {
showName();
cout << price<< endl; }

4:虚函数

  • 非虚函数(non-virtual)

不希望派生类(子类)去重新定义父类

子类重新定义父类的术语:override

  • 虚函数(virtual)

希望子类重新定义父类,而且子类已经有该函数的默认定义

  • 纯虚函数(pure virtual)

希望子类一定要重新定义父类,因为父类不存在默认定义

class shape{
public:
 //纯虚函数
 //因为子类形状对父类不可知,所以父类无法预设,只能子类自己实现
    virtual void drow() const=0;//virtual =0
 //虚函数
 //设计成虚函数是,如果子类想要打印更细致的错误信息,子类可以自己实现   
    virtual void error(const string& msg);
  //非虚函数
  //因为不管子类是什么(三角形,矩形),给对象生成编号的动作是一致的,父类可以实现
    int objectID() const;
};
打开文件

父类提供打开文件的函数,对所有文件来说:查找,搜索,关闭这些动作一样,只有:读取文件内容不同

所以:父类打开文件函数提供一个虚函数读取文件,这个函数由子类实现

在这里插入图片描述
如图:子类调用父类的函数,然后父类函数运行到虚函数后,又会去调用子类的函数

在这里插入图片描述

简单实现:

class cDocument{
public:
    void onFileOpen(){
        cout << "check file status!" << endl;
        cout << "open file !" << endl;
        serialize();//子类重载虚函数
        cout << "close file !" << endl;
        cout << "update file view!" << endl;
    }
    virtual void serialize() =0;
};
class cMydoc:public cDocument{
public:
    void serialize(){
        cout << "my file" << endl;
    }
};
int main(){
    cMydoc mydoc;
    mydoc.onFileOpen();
}

八:复合和继承同时出现

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

有两种:

  • 父类存在其他类,子类继承了父类

  • 子类继承了父类,子类存在其他类

子类继承父类,存在其他类对象

//假设类B继承类A,类B中有类C对象
class A{
public:
    A(int a):a(a) {
        cout << "构造函数A()" << endl;
    }
    ~A() { cout << "析构函数~A()"<<endl; }
    void getA() { cout <<"A::"<<a << endl; }
private:
    int a;
};
class C{
public:
    C(char ch):ch(ch){
        cout << "构造函数C()" << endl;
    }
    ~C() { cout << "析构函数~C()" << endl; }
    void getC() { cout <<"C::"<<ch << endl; }
private:
    char ch;
};
class B:public A{
public:
    B(int a,char ch,double x):A(a),obj(ch),x(x) {
        cout << "构造函数B()" << endl;
    }
    B(char ch,int a,double x):obj(ch),A(a),x(x) {
        cout << "构造函数B()" << endl;
    }
    ~B() { cout << "析构函数~B()" << endl; }
    C getOBJ() const { return obj; }
    void getB() { cout <<"B::"<<x << endl; }
private:
    C obj;
    double x;
};

运行结果:

int main(){
 B a(300,'A',19.87);
 B b('B', 900, 19.87);
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

构造顺序是首先调用继承的父类,其次调用组合中的实例对象,最后才是构造自己本身

B a(300,‘A’,19.87);

a.getA();

a.getB();

a.getOBJ().getC();

父类存在其他类,子类继承

//类B中有类C对象,类A继承类B
class C{
public:
    C(char ch):ch(ch){
        cout << "构造函数C()" << endl;}
    ~C() { cout << "析构函数~C()" << endl; }
    void getC() { cout <<"C::"<<ch << endl; }
private:
    char ch;
};
class B{
public:
    B(char ch,double x):obj(ch),x(x) {
        cout << "构造函数B()" << endl;}
    ~B() { cout << "析构函数~B()" << endl; }
    C getOBJ() const { return obj; }
    void getB() { cout <<"B::"<<x << endl; }
private:
    C obj;
    double x;
};
class A:public B{
public:
    A(int a,char c,double b):a(a),B(c,b){
        cout << "构造函数A()" << endl;
    }
    ~A() { cout << "析构函数~A()"<<endl; }
    void getA() { cout <<"A::"<<a << endl; }
private:
    int a;
};
int main(){
 A a(100, 'a', 99.89);
 a.getA();
 a.getB();
 a.getOBJ().getC();
}

在这里插入图片描述

这个很简单:

类中有复合:先复合构造再自己

类中有继承:先继承构造再自己

类A中有继承B,继承B中有复合C:先继承B(先复合C再自己B)再自己A

CBA

析构先自己,再复合或构造

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

LoRA:大模型的低阶自适用(使用BERT在IMDB数据集上运用LoRA微调)

文章目录 简介LoRA文章主要贡献LoRA技术模型图技术细节论文实验结果LoRA在bert的运用LoRA核心代码实战分析 简介 论文链接https://arxiv.org/pdf/2106.09685v2.pdf 本文将先介绍论文中的LoRA技术&#xff0c;然后以BERT为例在IMDB数据集上代码实现运用这项微调技术。 代码数…

Day 14 网络协议

常见网络设备&#xff1a;交换机 路由器 中继器 多协议网关&#xff08;路由器的前身&#xff09; 交换机&#xff1a;用于连接统一网络的设备&#xff0c;实现内网设备通信。 从广义上分为&#xff1a;局域网交换机&#xff0c;广域网交换机 从网络构成分为&#xff1a;接…

Prompt提示工程上手指南:基础原理及实践-思维树 (ToT)策略下的Prompt

前言 此篇文章已经是本系列的第五篇文章&#xff0c;之前我们已经将检索增强生成(RAG)策略&#xff0c;逐渐我们掌握的知识和技术都在不断提高&#xff0c;对于Prompt的技巧策略也不能只局限于局部运用而要适应LLM大模型的整体框架去进行改进休整。较为主流的LLM模型框架设计基…

通过adb 命令打印安装在第三方模拟器上的log

1&#xff0c;环境&#xff1a;Windows 11 &#xff0c;第三方模拟器 网易的MuMu 步骤&#xff1a; 1&#xff0c;打开cmd&#xff0c;输入 adb connect 172.0.0.1:7555 2&#xff0c;在cmd&#xff0c;再次输入adb logcat 回车

【Web】陇原战“疫“2021网络安全大赛 题解

目录 CheckIN eaaasyphp EasyJaba CheckIN 拿到附件&#xff0c;贴出关键代码 func getController(c *gin.Context) {cmd : exec.Command("/bin/wget", c.QueryArray("argv")[1:]...)err : cmd.Run()if err ! nil {fmt.Println("error: ", …

【HCIP】OSPF的高级特性

OSPF的高级特性1 --- 不规则区域 一、OSPF不规则区域类型 产生原因&#xff1a;区域划分不合理&#xff0c;导致的问题 1、非骨干区域无法和骨干区域保持连通 2、骨干区域被分割 造成后果&#xff1a;非骨干区域没和骨干区域相连&#xff0c;导致ABR将不会帮忙转发区域间的路由…

element-ui设置弹窗等级最高

通过参数:appendToBody"true"设置弹窗等级最高 主要是 :appendToBody“true”&#xff0c;其他参数可根据自己需求配置 <el-dialog :title"title" :visible.sync"isShow" top"5vh" :appendToBody"true"><el-image…

Web前端开发——Ajax,Axios概述及在Vue框架中的使用

前言&#xff1a; 整理下学习笔记&#xff0c;打好基础&#xff0c;daydayup!!! Ajax Ajax是什么&#xff1f; Ajax全称Asynchromous JavaScript And Xml&#xff0c;是异步的JavaScript和Xml。 Ajax的作用&#xff1f; 1&#xff0c;数据交换&#xff1a;通过Ajax可以给服务器…

uniapp 当前系统没有安装苹果根证书,是否打开证书目录(打开后依次安装证书

当你遇到这类问题时&#xff0c;说明你也极其的困惑&#xff01;这就是为啥大抵国内这些货色搞的东西总是不尽人意&#xff01;连开发者生态都搞不好&#xff0c;就急着吹嘘。 这是官方给的技术说明方案&#xff1a; 恭喜你&#xff0c;当你按照这个搞之后&#xff0c;你的问题…

Map与Set的模拟实现封装

目录 一. 底层原理 二. 红黑树节点的定义 三. 仿函数封装 四. 基本函数的封装 五. 迭代器的封装 5.1 迭代器的基本定义 5.2 *与->操作 5.3 迭代器的操作 5.3.1 右子树不为空 5.3.2 右子树为空 5.4 迭代器的--操作 5.4.1 当前节点的父节点…

CSS基础:最详细 padding的 4 种用法解析

你好&#xff0c;我是云桃桃。 一个希望帮助更多朋友快速入门 WEB 前端的程序媛。 云桃桃&#xff0c;大专生&#xff0c;一枚程序媛&#xff0c;感谢关注。回复 “前端基础题”&#xff0c;可免费获得前端基础 100 题汇总&#xff0c;回复 “前端工具”&#xff0c;可获取 We…

Adobe Premiere Pro将加入AI生成式功能,以提高视频编辑的效率;OpenAI宣布在东京设立亚洲首个办事处

&#x1f989; AI新闻 &#x1f680; Adobe Premiere Pro将加入AI生成式功能&#xff0c;以提高视频编辑的效率 摘要&#xff1a;Adobe宣布&#xff0c;将为Premiere Pro引入由生成式AI驱动的新功能&#xff0c;以提高视频编辑的效率。这些功能包括“生成扩展”&#xff0c;能…

免费开源多客圈子婚恋社交校园跑腿线上线下陪玩 源码交付 可打包小程序 支持二开!

聊天软件作为一种现代化的通讯工具&#xff0c;其好处可以总结如下&#xff1a; 1.方便快捷&#xff1a;聊天软件只要有网络连接&#xff0c;就可以随时随地与他人进行交流&#xff0c;不受时间和地点的限制&#xff0c;可以随时随地进行沟通&#xff0c;大大方便了人们的日常…

【结构型模式】装饰器模式

​一、装饰器模式概述 装饰器模式&#xff08;装饰者模式&#xff09;定义&#xff1a;装饰器模式动态地将责任附加到对象上。若要拓展功能&#xff0c;装饰者提供了比继承更有弹性地替代方案。&#xff08;对象结构型模型&#xff09;通俗点来说&#xff1a;动态的给一个对象增…

适用于 Windows 的 10 个顶级 PDF 编辑器 [免费和付费]

曾经打开PDF文件&#xff0c;感觉自己被困在数字迷宫中吗&#xff1f;无法编辑的文本、无法调整大小的图像以及签署感觉像是一件苦差事的文档&#xff1f;好吧&#xff0c;不用再担心了&#xff01;本指南解开了在 Windows 上掌握 PDF 的秘密&#xff0c;其中包含 10 款适用于 …

vscode vue template模板中 tab键无法快速补全

之前记得一直可以的突然不知道咋的就不行了… 解决办法: 菜单栏 - 文件 - 首选项 - 设置- emmet:tab ✔就好了

Flink CDC 的 debezium-json 格式和 debezium 原生格式是一回事吗?

博主历时三年精心创作的《大数据平台架构与原型实现&#xff1a;数据中台建设实战》一书现已由知名IT图书品牌电子工业出版社博文视点出版发行&#xff0c;点击《重磅推荐&#xff1a;建大数据平台太难了&#xff01;给我发个工程原型吧&#xff01;》了解图书详情&#xff0c;…

【介绍下负载均衡原理及算法】

&#x1f3a5;博主&#xff1a;程序员不想YY啊 &#x1f4ab;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f917;点赞&#x1f388;收藏⭐再看&#x1f4ab;养成习惯 ✨希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出…

IP协议如何进行地址管理?

如今&#xff0c;IP协议有两个版本&#xff0c;分别是IPv4和IPv6&#xff0c;IPv4是目前主要应用的版本。IPv4的IP地址是以4个字节的数字来表示的&#xff0c;比如 127.0.0.1。因此&#xff0c;IPv4所能表示IP地址的个数是2^32次方&#xff0c;也就是42亿多个&#xff0c;看起来…

48.HarmonyOS鸿蒙系统 App(ArkUI)常用组件的使用

48.HarmonyOS鸿蒙系统 App(ArkUI)常用组件的使用 按钮触发事件 toast信息提示 单选按钮 复选框 切换按钮&#xff0c;开关按钮 进度条 textbox,textinput,TextArea文本输入框 气泡提示 import prompt from ohos.prompt; import promptAction from ohos.promptAction; …