c++类与对象

最新推荐文章于 2024-07-08 21:32:26 发布
最新推荐文章于 2024-07-08 21:32:26 发布
阅读量1k 收藏 25
点赞数 32
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51506576/article/details/134747170
版权

目录

一、类和对象

1、封装

2、对象初始化和清理

1.构造函数和析构函数

2.构造函数调用规则

3.拷贝构造函数的调用时机和深浅拷

4.静态成员

5.补充

3、c++对象模型和this指针

1.成员和this指针

2.空指针访问成员函数以及const修饰成员函数

4、友元 

5、继承

1.继承方式和顺序

 2.继承同名成员处理方式

3.多继承和菱形继承

6、多态

1.多态基本概念

2.纯虚函数和抽象类

3.虚析构和纯虚析构

一、类和对象

类和对象：包含 属性（对象包含的特征），行为（对象可以执行的操作）

三大特性：封装，继承，多态。

1、封装

  • 将属性和行为作为一个整体

  • 将属性和行为加以权限控制（public，protected，private）

注：在C++中 struct和class唯一的区别就在于 默认的访问权限不同。struct默认权限为公共，class默认权限为private

#include <iostream>
#include <string>
using namespace std;

//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问

class Person
{
        //姓名  公共权限
public:
        string m_Name;

        //汽车  保护权限
protected:
        string m_Car;

        //银行卡密码  私有权限
private:
        int m_Password;

public:
        void func()
        {
                m_Name = "张三";
                m_Car = "拖拉机";
                m_Password = 123456;
        }
};

int main() {

        Person p;
        p.m_Name = "李四";
        //p.m_Car = "奔驰";  //保护权限类外访问不到
        //p.m_Password = 123; //私有权限类外访问不到

        system("pause");

        return 0;
}

2、对象初始化和清理

1.构造函数和析构函数

  • 构造函数（ 类名(){} ）：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用，可有参和重构（对象初始化）。

  • 析构函数（ ~类名(){} ）：主要作用在于对象销毁前系统自动调用，执行一些清理工作，不可有参和重构（清理）。

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    //无参（默认）构造函数
    Person() {
        cout << "无参构造函数!" << endl;
    }
    //有参构造函数
    Person(int a) {
        age = a;
        cout << "有参构造函数!" << endl;
    }
    //拷贝构造函数
    Person(const Person& p) {
        age = p.age;
        cout << "拷贝构造函数!" << endl;
    }
    //析构函数
    ~Person() {
        cout << "析构函数!" << endl;
    }
public:
    int age;
};

//构造函数分类和调用方式
void test01() {
    //1、构造函数分类
    // 按照参数分类分为  有参和无参构造   （无参又称为默认构造函数）
    // 按照类型分类分为  普通构造和拷贝构造
    //2、调用方式
    //括号法、显示法、隐式转换法


    //2.1  括号法，常用
    Person p;
    Person p1(10);
    //注意1：调用无参构造函数不能加括号，例：Person p2();如果加了编译器认为这是一个函数声明

    //2.2 显式法
    Person p2 = Person(10);//Person(10)单独写就是匿名对象  当前行结束之后，马上析构
    Person p3 = Person(p2);
    
    //2.3 隐式转换法
    Person p4 = 10; // Person p4 = Person(10); 
    Person p5 = p4; // Person p5 = Person(p4); 

    //注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
    //Person p6(p4);
}


int main() {
    test01();

    system("pause");

    return 0;
}

2.构造函数调用规则

默认情况下，c++编译器会给类添加3个函数的空实现

  • 默认构造函数(无参，函数体为空)
  • 默认析构函数(无参，函数体为空)
  • 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

注：虽然我们定义了有参构造函数或拷贝构造函数，但我们任然可以重写默认构造函数

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
        //无参（默认）构造函数
        Person() {
                cout << "无参构造函数!" << endl;
        }
        //有参构造函数
        Person(int a) {
                age = a;
                cout << "有参构造函数!" << endl;
        }
        //拷贝构造函数
        Person(const Person& p) {
                age = p.age;
                cout << "拷贝构造函数!" << endl;
        }
        //析构函数
        ~Person() {
                cout << "析构函数!" << endl;
        }
public:
        int age;
};


//构造函数调用规则
void test02()
{
    //如果提供有参构造，编译器不会提供默认构造，会提供拷贝构造
    //如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
    Person p1; //此时如果自己没有提供默认构造，会出错
    Person p2(10); //提供的有参
    Person p3(p2); //此时如果没有提供拷贝构造，编译器会提供

    //如果提供拷贝构造，编译器不会提供其他构造函数（有参构造函数和默认构造函数）
    Person p4; //此时如果自己没有提供默认构造，会出错
    Person p5(20); //此时如果自己没有提供有参，会出错
    Person p6(p5); //自己提供拷贝构造
}


int main() {

        test02();

        system("pause");

        return 0;
}

3.拷贝构造函数的调用时机和深浅拷

C++中拷贝构造函数调用时机通常有三种情况

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象
#include <iostream>
#include <string>
using namespace std;

//拷贝构造函数的调用
//1.- 使用一个已经创建完毕的对象来初始化一个新对象
void copy1() {
	cout << "1.- 使用一个已经创建完毕的对象来初始化一个新对象" << endl;
	MyClass m1;
	MyClass m2(m1);
}
//2.- 值传递的方式给函数参数传值
void t1(MyClass m) {
}
void copy2() {
	cout << "2.- 值传递的方式给函数参数传值" << endl;
	MyClass m1;
	t1(m1);
}
//3.- 以值方式返回局部对象
MyClass t2() {
	MyClass m1;
	cout << &(m1) << endl;
	//return m1;   //版本优化，直接返回m1不会调用拷贝构造函数。
	return MyClass(m1);
}
void copy3() {
	cout << "3.- 以值方式返回局部对象" << endl;
	MyClass m2=t2();
	cout << &(m2) << endl;
}

int main() {

    copy1();
    copy2();
    copy3();

    system("pause");

    return 0;
}

上述代码对于拷贝构造函数的调用都是浅拷贝，可能会造成一下问题：

  • 多个对象指向同一块内存，当一个对象被改变时，其他对象也会随之改变，从而破坏了程序的正确性。

  • 由于多个对象共享同一块内存，当其中一个对象被销毁时，它释放的内存也会被其他对象所依赖，从而导致内存泄漏。

浅拷贝：浅拷贝构造函数是将现有的对象复制一份它的内存地址，然后将该地址赋值给新的对象，这样两个对象指向同一个内存地址。但虽然两个对象指向同一块内存地址，但由于这是两个不同的对象，对象本身的地址是不一样的（所以上述m1和m2内存地址结果不一样）。

深拷贝：在堆区重新申请空间，进行拷贝操作，复制的是具体内容，可以解决浅拷贝问题。

#include <iostream>
#include <string>

using namespace std;

//深浅拷贝构造函数
class Person {
public:
    //无参（默认）构造函数
    Person() {
        cout << "无参构造函数!" << endl;
    }
    //有参构造函数
    Person(int age, int height) {
        cout << "有参构造函数!" << endl;
        m_age = age;
        m_height = new int(height);

    }
    //拷贝构造函数  
    Person(const Person& p) {
        cout << "拷贝构造函数!" << endl;
        //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
        m_age = p.m_age;
        m_height = new int(*p.m_height);

    }
    //析构函数
    ~Person() {
        cout << "析构函数!" << endl;
        if (m_height != NULL)
        {
            delete m_height;
        }
    }
public:
    int m_age;
    int* m_height;
};



void test04()
{
    Person p1(18, 180);

    Person p2(p1);

    cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

    cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

    test04();

    system("pause");

    return 0;
}

4.静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

  • 静态成员变量

    • 所有对象共享同一份数据

    • 在编译阶段分配内存

    • 类内声明，类外初始化

  • 静态成员函数

    • 所有对象共享同一个函数

    • 静态成员函数只能访问静态成员变量

#include <iostream>
#include<string>

using namespace std;

//静态成员
class Person
{
public:
	static int m_A; //静态成员变量
	int m_C;
	static void func1()
	{
		cout << "func1调用" << endl;
		m_A = 100;
		//m_C = 100; //错误，不可以访问非静态成员变量
	}


private:
	static int m_B;			//静态成员变量也是有访问权限的
	static void func2()		//静态成员函数也是有访问权限的
	{
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;
int Person::m_B = 10;
//静态成员变量
void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;
	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
//静态成员函数
void test02()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func1();

	//2、通过类名
	Person::func1();
	//Person::func2(); //私有权限访问不到
}


int main() {

    test01();
    test02();

    system("pause");

    return 0;
}

5.补充

C++初始化列表语法：用来初始化属性构造函数()：属性1(值1),属性2（值2）... {}

#include <iostream>
#include<string>

using namespace std;

class Person {
public:

        传统方式初始化
        //Person(int a, int b, int c) {
        //        m_A = a;
        //        m_B = b;
        //        m_C = c;
        //}

        //初始化列表方式初始化
        Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
        void PrintPerson() {
                cout << "mA:" << m_A << endl;
                cout << "mB:" << m_B << endl;
                cout << "mC:" << m_C << endl;
        }
private:
        int m_A;
        int m_B;
        int m_C;
};

int main() {

        Person p(1, 2, 3);
        p.PrintPerson();


        system("pause");

        return 0;
}
mA: 1
mB: 2
mC: 3

当类中成员是其他类对象时，我们称该成员为对象成员。

构造的顺序是 ：先调用对象成员的构造，再调用本类构造，析构顺序与构造相反

#include <iostream>
#include<string>

using namespace std;

class Phone
{
public:
        Phone(string name)
        {
                m_PhoneName = name;
                cout << "Phone构造" << endl;
        }

        ~Phone()
        {
                cout << "Phone析构" << endl;
        }

        string m_PhoneName;

};


class Person
{
public:

        //初始化列表可以告诉编译器调用哪一个构造函数
        Person(string name, string pName) :m_Name(name), m_Phone(pName)
        {
                cout << "Person构造" << endl;
        }

        ~Person()
        {
                cout << "Person析构" << endl;
        }

        void playGame()
        {
                cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
        }

        string m_Name;
        Phone m_Phone;

};
void test01()
{
        //当类中成员是其他类对象时，我们称该成员为 对象成员
        //构造的顺序是 ：先调用对象成员的构造，再调用本类构造
        //析构顺序与构造相反
        Person p("张三" , "苹果X");
        p.playGame();

}


int main() {

        test01();

        system("pause");

        return 0;
}
Phone构造
Person构造
张三 使用苹果X 牌手机! 
Person析构
Phone析构

3、c++对象模型和this指针

1.成员和this指针

在C++中，类内的成员变量和成员函数分开存储：只有非静态成员变量才属于类的对象上

c++通过提供特殊的对象指针，this指针。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针，this指针不需要定义，直接使用即可

this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分

  • 在类的非静态成员函数中返回对象本身，可使用return *this

#include <iostream>
#include<string>

using namespace std;

//this指针
class Person {
public:
    Person() {
        age = 0;
    }
    int age;            //非静态成员变量占对象空间
    static int name;    //静态成员变量不占对象空间
    void func() {       //函数也不占对象空间，所有函数共享一个函数实例
        cout << "mA:" << this->age << endl;
    }
    static void sfunc() {}    //静态成员函数也不占对象空间
    
    //this指针
    Person(int age)
    {
        this->age = age;        //1、当形参和成员变量同名时，可用this指针来区分
    }
    Person& PersonAddPerson(Person p)
    {
        this->age += p.age;
        return *this;         //返回对象本身
    }
};

void test01()
{
    Person p1(10);
    cout << "p1.age = " << p1.age << endl;

    Person p2(10);
    p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
    cout << "p2.age = " << p2.age << endl;
}

int main() {
    cout << sizeof(Person) << endl;
    test01();
    system("pause");

    return 0;
}

sizeof(Person)  只有4，说明非静态变量才属于类的对象上

p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);

函数链式调用：连续调用了三次PersonAddPerson函数，并依次将p1对象的age成员变量加到p2对象的age成员变量中，最后返回的结果是p2对象的引用。

2.空指针访问成员函数以及const修饰成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针。如果用到this指针，需要加以判断保证代码的健壮性

常函数：

  • 成员函数后加const后我们称为这个函数为常函数

  • 常函数内不可以修改成员属性

  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const称该对象为常对象

  • 常对象只能调用常函数

#include <iostream>
#include<string>

using namespace std;

//空指针和const
class Person {
public:
    Person() {
        m_A = 0;
        m_B = 0;
    }
    void ShowClassName() {
        cout << "我是Person类!" << endl;
    }
    void ShowPerson1() {
        if (this == NULL) {
            return;
        }
        cout << mAge << endl;
    }
    //this指针的本质是一个指针常量，指针的指向不可修改
    //如果想让指针指向的值也不可以修改，需要声明常函数
    void ShowPerson2() const {
        //const Type* const pointer;
        //this = NULL; //不能修改指针的指向 Person* const this;
        //this->mA = 100; //但是this指针指向的对象的数据是可以修改的
        //const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
        this->m_B = 200;
    }
    void MyFunc() {
        cout << "调用非常函数" << endl;
    }

public:
    int mAge;
    int m_A;
    mutable int m_B; //可修改 可变的
};
//空指针访问成员函数
void test01()
{
    Person* p = NULL;
    p->ShowClassName(); //空指针，可以调用成员函数
    p->ShowPerson1();  //但是如果成员函数中用到了this指针，就不可以了
}

//const修饰成员函数 常对象
void test02() {

    const Person p; //常量对象  
    cout << p.m_A << endl;
    //p.mA = 100; //常对象不能修改成员变量的值,但是可以访问
    p.m_B = 100; //但是常对象可以修改mutable修饰成员变量
    cout << p.m_B << endl;
    //常对象访问成员函数
    p.ShowPerson2(); 
    cout << p.m_B << endl;
    //p.MyFunc(); //不可访问非常函数
}
int main() {

    test01();
    test02();
    system("pause");
    return 0;
}

4、友元 

在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

例：将你游戏账号里的游戏共享给你朋友的账号

友元的目的：让一个函数或者类 访问另一个类中私有成员

友元的关键字：friend

友元的三种实现

  • 全局函数做友元

  • 类做友元

  • 成员函数做友元

#include <iostream>
#include<string>

using namespace std;


class MyGame;

class FriendGame2 {
public:
    FriendGame2();
    void share1();
    void share2();

private:
    MyGame* game;
};

class MyGame
{
    //告诉编译器 share全局函数 是 MyGame类的好朋友，可以访问类中的私有内容
    friend void share(MyGame game);
    //告诉编译器 FriendFame1类是MyGame类的好朋友，可以访问到MyGame类中私有内容
    friend class FriendGame1;
    //告诉编译器  FriendGame2类中的share1成员函数 是MyGame类好朋友，可以访问私有内容
    friend void FriendGame2::share1();

public:
    MyGame();
public:
    string game1; 

private:
    string game2; //卧室
};

class FriendGame1 {
public:
    FriendGame1() {
        //MyGame m;
        //game = &m;  //不能直接传入地址，要在堆区创建内存，不然构造函数执行完就释放了
        game = new MyGame;
    }
    void share() {
        cout << "好友想访问： " << game->game1 << endl;
        cout << "好友想访问： " << game->game2 << endl;
    }

private:
    MyGame* game;
};
MyGame::MyGame()
{
    this->game1 = "赛博朋克2077";
    this->game2 = "完蛋，我被美女包围了！";
}
FriendGame2::FriendGame2() {
    //MyGame m;
    //game = &m;  //不能直接传入地址，要在堆区创建内存，不然构造函数执行完就释放了
    game = new MyGame;
}
void FriendGame2::share1() {
    cout << "好友想访问： " << game->game1 << endl;
    cout << "好友想访问： " << game->game2 << endl;
}
void FriendGame2::share2() {
    cout << "好友想访问： " << game->game1 << endl;
}

//全局函数做友元
void share(MyGame game) {
    cout << "好友想访问： " << game.game1 << endl;
    cout << "好友想访问： " << game.game2 << endl;
    //正常类外是不能访问是有成员game2的，但由于友元，可以访问类中的私有内容
}
void test01()
{
    cout << "1.全局函数做友元" << endl;
    MyGame b;
    share(b);
}
//类做友元
void test02() {
    cout << "2.类做友元" << endl;
    FriendGame1 fgame;
    fgame.share();
}
//成员函数做友元
void test04() {
    cout << "3.成员函数做友元" << endl;
    FriendGame2 fg;
    fg.share1();
    fg.share2();
}

int main() {
    test01();
    test02();
    test04();
    system("pause");
    return 0;
}

 

 注意：如果整个类被声明为另一个类的友元，那么两个类的声明顺序不需要特定。这是因为友元关系是对称的，即如果类A是类B的友元，那么类B也自动成为类A的友元。这意味着两个类都可以访问对方的私有和保护成员。

然而，当特定的成员函数被声明为友元时，情况就有所不同了。在这种情况下，被声明为友元的成员函数必须在它所属的类之后声明，以确保编译器在处理友元声明时已经看到了该成员函数的完整声明。所以成员函数做友元时，两个类的声明顺序是特定的

5、继承

继承的好处：可以减少重复的代码

继承的语法：class 子类 : 继承方式 父类

class A : public B;

A 类称为子类 或 派生类         B 类称为父类 或 基类

1.继承方式和顺序

  • 公共继承

  • 保护继承

  • 私有继承

#include <iostream>
#include <string>
using namespace std;

//继承方式
class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
//公共继承
class Son1 :public Base1
{
public:
    void func()
    {
        m_A; //可访问 public权限
        m_B; //可访问 protected权限
        //m_C; //不可访问
    }
};
void myClass()
{
    Son1 s1;
    s1.m_A; //其他类只能访问到公共权限
}

//保护继承
class Son2 :protected Base1
{
public:
    void func()
    {
        m_A; //可访问 protected权限
        m_B; //可访问 protected权限
        //m_C; //不可访问
    }
};
void myClass2()
{
    Son2 s;
    //s.m_A; //不可访问
}

//私有继承
class Son3 :private Base1
{
public:
    Son3()
    {
        cout << "Son构造函数!" << endl;
    }
    void func()
    {
        m_A; //可访问 private权限
        m_B; //可访问 private权限
        //m_C; //不可访问
    }
    ~Son3()
    {
        cout << "Son析构函数!" << endl;
    }
};
class GrandSon3 :public Son3
{
public:
    GrandSon3()
    {
        cout << "GrandSon构造函数!" << endl;
    }
    void func()
    {
        //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
        //m_A;
        //m_B;
        //m_C;
    }
    ~GrandSon3()
    {
        cout << "GrandSon析构函数!" << endl;
    }
};

int main() {
    GrandSon3 g;
    return 0;
}

 

 总结：当一个类继承自另一个类时，它会继承父类的所有属性和方法，并且可以添加自己的属性和方法。子类可以使用父类的属性和方法（子类不可访问父类私有成员），也可以通过重写（override）父类的方法来改变其行为。在子类中，可以使用super关键字来调用父类的方法。同时，可以通过继承访问修饰符（public、protected和private）决定子类成员的访问权限。另外，继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

 2.继承同名成员处理方式

  • 访问子类同名成员 直接访问即可

  • 访问父类同名成员 需要加作用域

#include <iostream>
#include <string>

using namespace std;

class Base {
public:
        Base()
        {
                m_A = 100;
        }

        void func()
        {
                cout << "Base - func()调用" << endl;
        }

        void func(int a)
        {
                cout << "Base - func(int a)调用" << endl;
        }

public:
        int m_A;
};


class Son : public Base {
public:
        Son()
        {
                m_A = 200;
        }

        //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
        //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
        void func()
        {
                cout << "Son - func()调用" << endl;
        }
public:
        int m_A;
};

void test01()
{
        Son s;

        cout << "Son下的m_A = " << s.m_A << endl;
        cout << "Base下的m_A = " << s.Base::m_A << endl;

        s.func();
        s.Base::func();
        s.Base::func(10);

}
int main() {

        test01();

        system("pause");
        return 0;
}

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可

  • 访问父类同名成员 需要加作用域

#include <iostream>
#include <string>

using namespace std;

class Base {
public:
        static void func()
        {
                cout << "Base - static void func()" << endl;
        }
        static void func(int a)
        {
                cout << "Base - static void func(int a)" << endl;
        }

        static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
        static void func()
        {
                cout << "Son - static void func()" << endl;
        }
        static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
        //通过对象访问
        cout << "通过对象访问： " << endl;
        Son s;
        cout << "Son  下 m_A = " << s.m_A << endl;
        cout << "Base 下 m_A = " << s.Base::m_A << endl;

        //通过类名访问
        cout << "通过类名访问： " << endl;
        cout << "Son  下 m_A = " << Son::m_A << endl;
        cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
        //通过对象访问
        cout << "通过对象访问： " << endl;
        Son s;
        s.func();
        s.Base::func();

        cout << "通过类名访问： " << endl;
        Son::func();
        Son::Base::func();
        //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
        Son::Base::func(100);
}
int main() {

        //test01();
        test02();

        system("pause");

        return 0;
}

3.多继承和菱形继承

C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

#include <iostream>
#include <string>

using namespace std;


class Base1 {
public:
        Base1()
        {
                m_A = 100;
        }
public:
        int m_A;
};

class Base2 {
public:
        Base2()
        {
                m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
        }
public:
        int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
        Son()
        {
                m_C = 300;
                m_D = 400;
        }
public:
        int m_C;
        int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
        Son s;
        cout << "sizeof Son = " << sizeof(s) << endl;
        cout << s.Base1::m_A << endl;
        cout << s.Base2::m_A << endl;
}

int main() {

        test01();

        system("pause");

        return 0;
}

 

菱形继承概念：两个派生类继承同一个基类，又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石继承。

#include <iostream>
#include <string>

using namespace std;

class Animal
{
public:
        int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
        SheepTuo st;
        st.Sheep::m_Age = 100;
        st.Tuo::m_Age = 200;

        cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
        cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
        cout << "st.m_Age = " << st.m_Age << endl;
}


int main() {

        test01();

        system("pause");

        return 0;
}

注：菱形继承会造成重复继承和二义性问题，需要利用虚继承来解决这个问题。原理是在虚继承中，派生类会在对象内部创建一个指向虚基类的指针，称为虚基类指针（vbptr）。这个指针指向一个虚基类表（vbtable），用于存储虚基类的信息和偏移量。不过虚继承虽然解决了菱形继承的问题，但也带来了新的开销和复杂性。虚继承会增加程序的内存占用和运行时间，因为每个虚基类都需要额外的指针和表来进行管理。所以一般不推荐多继承和菱形继承。

6、多态

1.多态基本概念

多态是C++面向对象三大特性之一

多态分为两类

  • 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名

  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址

  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

#include <iostream>
#include <string>

using namespace std;

class Animal
{
public:
    //Speak函数就是虚函数
    //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};
class Cat :public Animal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};
class Dog :public Animal
{
public:

    void speak()
    {
        cout << "小狗在说话" << endl;
    }

};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编
void DoSpeak(Animal& animal)
{
    animal.speak();
}
//多态满足条件： 
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象
void test01()
{
    Cat cat;
    DoSpeak(cat);
    Dog dog;
    DoSpeak(dog);
}

int main() {
    test01();
    system("pause");
    return 0;
}

 

2.纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。当类中有了纯虚函数，这个类也称为抽象类

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;

抽象类特点：

  • 无法实例化对象

  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include <iostream>
#include <string>

using namespace std;


class Base
{
public:
        //纯虚函数
        //类中只要有一个纯虚函数就称为抽象类
        //抽象类无法实例化对象
        //子类必须重写父类中的纯虚函数，否则也属于抽象类
        virtual void func() = 0;
};

class Son :public Base
{
public:
        virtual void func() 
        {
                cout << "func调用" << endl;
        };
};

void test01()
{
        Base * base = NULL;
        //base = new Base; // 错误，抽象类无法实例化对象
        base = new Son;
        base->func();
        delete base;//记得销毁
}

int main() {

        test01();

        system("pause");

        return 0;
}

 

3.虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象

  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

#include <iostream>
#include <string>

using namespace std;

class Animal {
public:

        Animal()
        {
                cout << "Animal 构造函数调用！" << endl;
        }
        virtual void Speak() = 0;

        //析构函数加上virtual关键字，变成虚析构函数
        //virtual ~Animal()
        //{
        //        cout << "Animal虚析构函数调用！" << endl;
        //}


        virtual ~Animal() = 0;
};

Animal::~Animal()
{
        cout << "Animal 纯虚析构函数调用！" << endl;
}

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
        Cat(string name)
        {
                cout << "Cat构造函数调用！" << endl;
                m_Name = new string(name);
        }
        virtual void Speak()
        {
                cout << *m_Name <<  "小猫在说话!" << endl;
        }
        ~Cat()
        {
                cout << "Cat析构函数调用!" << endl;
                if (this->m_Name != NULL) {
                        delete m_Name;
                        m_Name = NULL;
                }
        }

public:
        string *m_Name;
};

void test01()
{
        Animal *animal = new Cat("Tom");
        animal->Speak();

        //通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
        //怎么解决？给基类增加一个虚析构函数
        //虚析构函数就是用来解决通过父类指针释放子类对象
        delete animal;
}

int main() {

        test01();

        system("pause");

        return 0;
}

 

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

3. 拥有纯虚析构函数的类也属于抽象类

weixin_51506576
关注
  • 32
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++类与对象
dergeder的博客
12-29 401
类是一种数据类型，设计时系统不为类分配存储空间，所以不能对类的数据成员初始化。类中的任何数据成员也不能使用关键字 extern、auto 或 register 限定其存储类型。 成员函数可以直接使用类定义中的任一成员，可以处理数据成员，也可调用函数成员。 成员函数在类内声明，在类外或者类内都可定义，类外定义：返回值类型 类名::函数名(参数表) 1、类的设计 class CGoods { private: char Name[20]; int Amount; float Price; float T
C++ 类与对象
Chroniccandy的博客
08-20 596
一.类的构成 1.1 类与结构 类由结构体演变而来 两者之间虽然相似 但是也有很大的差异 结构是C的一种自定义的数据类型，它把相关联的数据元素组成一个单独的统一体 #include <iostream.h> struct Date { int year; int month; int day; }; int main() { Date date1; date1.year=2003; date1.month=8; date1.day=25;
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
C++类和对象详细总结
热门推荐
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++类与对象_简单练习题
Achievek的博客
03-25 8420
## C++ 类与对象练习题: **在主函数中生成一个时钟对象，并为其设置时间和显示时间** 这是一道入门题,主要是为了熟悉类与对象,以及成员函数,数据成员的实现; 在此先强调几点与C的区别或者说创建类与对象的注意点: 1.C++的类习惯在主函数外定义,在主函数内部用类声明对象,类似C中的结构体,(当然结构体也可以在内部定义,只是习惯外部); 2.c++的类内函数声明,...
c++ 类与对象
11-10
c++类与对象实习举例。
C++ 类与对象习题
10-14
C++ 类与对象习题，都是入门知识，给初学者参考^-^
C++ 类与对象之日期类的创建主要代码
02-21
使用的是C++的类与对象、运算符重载、构造函数、析构函数等知识创建了一个有关于获取某年某月天数、某年某月某日之间的日期大小等于的对比，以及某年某月某日增加某天数的日期类、内容包括有增加天数、减少天数，...
C++类与对象-继承（详细讲解）
03-24
C++类与对象-继承（详细讲解）
C++类与对象PPT
08-31
详细介绍了C++中类与对象的特点和应用，供初学者学习使用
C++类与对象点圆练习.sln
04-05
最近学习C++到类与对象，黑马程序员有个点圆示例，想看看源代码没找到只好手撸一把
C++类和对象，思维导图
04-24
C++类和对象，会跟着文章更新而更新
大学C++ 类与对象 课件
06-14
我们上课用的课件，对于非计算机专业的应该是有用 的
C++类与对象习题及解答.doc
10-20
C++类与对象习题及解答.doc
c++ 类和对象(上)
12-21
文章目录类与对象的初步认知类的定义类的信息隐蔽及封装性类的对象大小类成员函数的this指针 c语言到c++，必须要先知道的基础知识！请戳下面的文章链接 —————->>>>>点我，开始入门c++ 类与对象的初步认知 C语言...
初始C++
最新发布
2302_81016149的博客
07-08 626
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
c++习题08-计算星期几
码到成龚的博客
07-03 582
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值