类和对象笔记

用户254701008882026-02-09 9:43

封装

访问权限

访问权限有三种：

  1. 公共权限 public 成员 类内类外都可访问
  2. 保护权限 protected 成员 类内可以访问 类外不可访问（）
  3. 私有权限 private 成员 类内可以访问 类外不可访问
ini 复制代码 
class Person
{
    public:
        string m_name;
    protected:
        string m_car;
    private:
        int m_password;
    public:
        void func()
        {
            m_name="张三";
            m_car="拖拉机";
            m_password=123456;
        }
};

struct和class的区别

在c++中struct和class唯一区别在于默认的访问权限不同

  • class默认权限为私有
  • struct默认权限为公共

对象特征

构造函数和析构函数

两个函数被编译器自动调用，如果不提供构造和析构，编译器会提供空实现的两个函数 构造函数的主要作用在于创建对象时为对象的成员属性赋值，在创建对象时调用；析构函数主要作用在于执行一些清理工作，在对象销毁前调用 构造函数语法： 类名(){}

  1. 构造函数没有返回值，也不写void
  2. 函数名称与类名相同
  3. 构造函数有参数，因此可以发生重载
  4. 程序在调用对象时会自动调用构造，无需手动调用，且只会调用一次

析构函数语法： ~类名(){}

  1. 析构函数没有返回值也不写void
  2. 函数名称与类名相同，在名称前加上符号~
  3. 析构函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
c 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    Person()
    {
        cout << "Person构造函数的调用" << endl;
    }
    ~Person()
    {
        cout << "Person析构函数的调用" << endl;
    }
};
void text01()
{
    Person p;
}
int main()
{
    text01();
    return 0;
}

构造函数的分类及调用

两种分类方式：

  • 按参数分为：有参构造和无参构造
  • 按类型分为：普通构造和拷贝构造

三种调用方式：

  • 括号法
  • 显示法
  • 隐式转换法
c 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    Person()
    {
        cout << "无参构造" << endl;
    }
    Person(int a)
    {
        cout << "有参构造，a=" << a << endl;
    }
    Person(const Person& p)
    {
        cout << "拷贝构造" << endl;
    }
};
void text01()
{
    Person p1;//无参构造
    Person p2(3);//有参构造且括号法
    Person p3(p1);//拷贝构造且括号法
    Person p4=Person(10);//有参构造且显示法
    Person p5=Person(p1);//拷贝构造且显示法
    Person p6=10;//有参构造且隐式转换法
    Person p7=p1;//拷贝构造且隐式转换法
    /*
    p4 p5等号右边的是匿名对象，如果只写匿名对象，如  Person(10)； ,则当前行执行结束后，系统会立即回收掉匿名对象
    */
}
int main()
{
    text01();
    return 0;
}

调用默认构造函数时不要加小括号Person p();,编译器会认为是函数声明,不会认为在创建对象 不要利用拷贝构造函数初始化匿名对象 Person(p3); 编译器认为Person(p3)==Person p3; 重定义

拷贝构造函数的调用时机

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

  • 使用一个已经创建完毕的对象来初始化一个对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象
c 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    Person(int m_age)
    {
        cout << "Person的构造函数调用" << endl;
        age = m_age;
    }
    Person(const Person& p)
    {
        cout << "Person的拷贝构造函数调用" << endl;
        age = p.age;
    }
    ~Person()
    {
        cout << "Person的析构函数调用" << endl;
    }
    int age = 10;
};
void dowork(Person p)
{
​
}
Person dowork2(int m_age)
{
    Person p(m_age);
    return p;
}
void text01(int m_age)
{
    Person p1(m_age);
    Person p2(p1);
    cout << "p2的年龄为" << p2.age << endl;
}
void text02(int m_age)
{
    Person p3(m_age);
    dowork(p3); 
}
void text03(int m_age)
{
    Person p4 = dowork2(m_age);
}
int main()
{
    text01(20);//使用一个已经创建完毕的对象来初始化一个对象
    text02(20);//值传递的方式给函数参数传值
    text03(20);//以值方式返回局部对象
    return 0;
}

构造函数调用规则

默认情况下，c++编译器至少给一个类添加三个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

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

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝工作 深拷贝：在堆区重新申请空间，进行拷贝操作

arduino 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
​
    Person(int age,int height)
    {
        m_age = age;
        m_height = new int(height);
        cout << "Person的有参构造函数调用" << endl;
    }
    ~Person()
    {
        if (m_height != NULL)
        {
            delete m_height;
            m_height = NULL;
        }
        cout << "Person的析构函数调用" << endl;
    }
    int m_age;
    int* m_height;
};
void text01(int age, int height)
{
    Person p1(age, height);
    Person p2(p1);
}
int main()
{
    text01(18, 180);
    return 0;
}

以上代码运行会报错，原因是浅拷贝操作将p1中m_height的地址简单拷贝给了p2，p2中m_height指向的内存空间delete后(p2位于栈区，p2先出)，p1再次delete导致非法操作 浅拷贝的问题要利用深拷贝来解决

ini 复制代码 
Person(const Person& p)
{
    m_age = p.m_age;
    //m_height = p.m_height;//这是系统默认的浅拷贝
    m_height=new int(*p.m_height);//深拷贝
}

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表

语法： 构造函数():属性1(值1),属性2(值2)...{}

类对象作为类成员

c++类中的成员可以是另一个类的对象，我们称该成员为对象成员 例如：

css 复制代码 
class A{}
class B
{
    A a;
}

B类中有对象作为成员，A为对象成员

c 复制代码 
#include<iostream>
#include<string>
using namespace std;
class phone
{
public:
    phone(string name):pname(name)
    {
​
    }
    string pname;
    string money;
};
class person
{
public:
    person(string name,string pname):m_name(name),iphone(pname)//隐式转换法
    {
​
    }
    string m_name;
    phone iphone;
};
int main()
{
    person man("xiaoming", "iphone12");
    cout << man.m_name << man.iphone.pname << endl;
}

当其他类对象作为本类成员，构造时候先构造类对象，再构造本类，析构时相反

静态成员

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

  • 静态成员变量

    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化

  • 静态成员函数

    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量
arduino 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    static int m_A;
};
int Person::m_A = 1;
void text01()
{
    Person p;
    cout << p.m_A << endl;
}
int main()
{
    text01();
    return 0;
}

静态成员变量不属于某个对象上，所有对象都共享同一份数据，因此静态成员变量有两种访问方式

  1. 通过对象进行访问 p.m_A
  2. 通过类名进行访问 Person::m_A

this指针

this指针指向被调用的成员函数所属的对象 this指针是隐含每一个非静态成员函数内的一种指针，不需要被定义，可以直接使用 this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可使用return *this
arduino 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    Person(int age)
    { 
        this->age = age;
    }
    Person & PersonAddAge(Person& p)
    {
        this->age += p.age;
        return *this;
    }
    int age;
};
void text01()
{
    Person p1(18);
    cout << p1.age << endl;
}
void text02()
{
    Person p2(10);
    Person p3(10);
    p2.PersonAddAge(p3).PersonAddAge(p3).PersonAddAge(p3).PersonAddAge(p3);//链式编程思想
    cout << p2.age << endl;
}
int main()
{
    text01();
    text02();
    return 0;
}

空指针访问成员函数

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

c 复制代码 
#include<iostream>
using namespace std;
class Person
{
public:
    void showPersonAge()
    {
        //if(this==NULL)
         // return;
        cout << m_age << endl;
    }
    void showClassName()
    {
        cout << "Person" << endl;
    }
    int m_age = 10;
};
void text01()
{
    Person* p = NULL;
    p->showPersonAge();//这行代码会报错，原因在于成员函数中使用了m_age这个属性，每个属性前默认有this->，而p为空指针
    p->showClassName();
}
int main()
{
    text01();
    return 0;
}

const修饰成员函数

常函数：

  • 成员函数后加const我们称这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数

友元

友元的目的是让一个函数或类访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元
c 复制代码 
#include<iostream>
using namespace std;
class Person
{
    friend void func();//全局函数做友元
public:
    string m_A = "aaa";
private:
    string m_B = "bbb";
};
void func()
{
    Person p1;
    cout << p1.m_A << endl;
    cout << p1.m_B << endl;
}
int main()
{
    func();
    return 0;
}

继承

继承方式

语法： class 派生类；继承方式 基类{} 继承方式一共三种：

  • 公共继承 public
  • 保护继承 protected
  • 私有继承 private

基类中的private派生类不可访问，保护继承基类的public在派生类中为protected，私有继承基类的public和protected在派生类中都为private

继承中的构造和析构顺序

派生类继承基类后，当创建派生类对象，也会调用基类的构造函数 基类和派生类构造和析构的顺序：

c 复制代码 
#include<iostream>
using namespace std;
class Base
{
public:
    Base()
    {
        cout << "基类构造" << endl;
    }
    ~Base()
    {
        cout << "基类析构" << endl;
    }
};
class Son :public Base
{
public:
    Son()
    {
        cout << "派生类构造" << endl;
    }
    ~Son()
    {
        cout << "派生类析构" << endl;
    }
};
void text01()
{
    Son s1;
}
int main()
{
    text01();
    return 0;
}

即基类先于派生类构造，后于派生类析构

同名（静态）成员处理方式

  • 访问派生类同名成员，直接访问即可
  • 访问基类同名成员，需要加作用域
c 复制代码 
#include<iostream>
using namespace std;
class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    void func()
    {
        cout << m_A << endl;
    }
public:
    int m_A ;
};
class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }
    void out()
    {
        cout << m_A << endl << Base::m_A << endl;
    }
    void func()
    {
        cout << m_A << endl;
    }
public:
    int m_A;
};
void text01()
{
    Son s1;
    s1.out();//访问同名属性
    s1.func();
    s1.Base::func();//访问同名方法
}
int main()
{
    text01();
    return 0;
}

如果派生类中出现和基类同名的成员函数，派生类的同名成员会隐藏掉父类中所有同名成员函数（包括重载）

如果想访问，需要加作用域

多继承语法

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

语法： class 派生类 ： 继承方式 基类1，继承方式 基类2...

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

实际开发中不建议用多继承

菱形继承

菱形继承概念：

  • 两个派生类继承同一个基类
  • 又有某个类同时继承这两个派生类
  • 这种继承被称为菱形继承（钻石继承）
arduino 复制代码 
#include<iostream>
using namespace std;
class BBase
{
public:
    int m_A;
};
class Base1 :public BBase
{
​
};
class Base2 :public BBase
{
​
};
class Son :public Base1, public Base2
{
​
};
void text01()
{
    Son s1;
    s1.Base1::m_A = 10;
    s1.Base2::m_A = 20;
​
}
int main()
{
    text01();
    return 0;
}

菱形继承导致相同的数据m_A有两份，导致资源浪费，可以用虚继承来解决

关键字：virtual

虚继承后相同的数据只有一份

arduino 复制代码 
#include<iostream>
using namespace std;
class BBase
{
public:
    int m_A;
};
class Base1 :virtual public BBase
{
​
};
class Base2 :virtual public BBase
{
​
};
class Son : public Base1, public Base2
{
​
};
void text01()
{
    Son s1;
    s1.Base1::m_A = 10;
    s1.Base2::m_A = 20;
    cout << s1.m_A << endl;
}
int main()
{
    text01();
    return 0;
}

多态

多态基本概念

多态分为两类：

  • 静态多态：函数重载和运算符重载属于静态多态，复用函数名
  • 动态多态：派生类和虚函数实现运行时多态

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

  • 静态多态的函数地址早绑定 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 运行阶段确定函数地址
csharp 复制代码 
#include<iostream>
using namespace std;
class Animal
{
public:
     void Speak()
    {
        cout << "jiao" << endl;
    }
};
class Cat :public Animal
{
public:
    void Speak()
    {
        cout << "mmm" << endl;
    }
};
void DoSpeak(Animal & animal)
{
    animal.Speak();
}
void text01()
{
    Cat cat;
    DoSpeak(cat);
​
}
int main()
{
    text01();
}

以上代码中，DoSpeak函数的形参为Animal类的对象，传入的实参为Cat类的对象不报错，输出为"jiao"

不报错原因：向上转型

  • Cat是Animal的子类
  • 所以Cat都具有Animal的所有特性

输出为"jiao"原因：早绑定

  • Speak() 不是虚函数
  • animal 是 Animal& 类型
  • 编译器看到 animal.Speak()，知道 animal 是 Animal 类型，所以绑定到 Animal::Speak()

输出为"mmm"需要使用虚函数（晚绑定）virtual void Speak()

动态多态满足条件：

  • 有继承关系
  • 派生类重写基类的虚函数（函数返回值类型 函数名 参数列表 完全一致称为重写）

动态多态使用：基类的指针或引用指向派生对象

多态的原理

c 复制代码 
class Animal
{
public:
     void Speak()
    {
        cout << "jiao" << endl;
    }
};

当写下如上代码时，会生成一个指向虚函数表vftable的指针vfptr，表的内部记录一个虚函数Speak的地址&Animal::Speak,写下派生类时会继承基类的vfptr和虚函数表，当派生类重写了基类的虚函数，接下来派生类的虚函数表内部会替换成派生类的虚函数地址，当基类的指针或者引用指向派生类对象时候，发生多态

纯虚函数和抽象类

在多态中，通常基类中虚函数的实现是毫无意义的，主要都是调用派生类重写的内容

因此可以将虚函数改为纯虚函数

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

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名（）=0

类名::类名(){}

纯虚析构需要声明也需要实现,因为派生类析构函数会自动调用基类析构函数，如果基类纯虚析构函数没有实现，链接时会报错。

arduino 复制代码 
#include <iostream>
using namespace std;
​
class Base {
public:
    virtual ~Base() = 0;  // 纯虚析构函数声明
};
​
// 必须在类外提供实现！
Base::~Base() {
    cout << "Base::~Base() called" << endl;
}
​
class Derived : public Base {
public:
    ~Derived() override {
        cout << "Derived::~Derived() called" << endl;
    }
};
​
int main() {
    Base* ptr = new Derived();
    delete ptr;  // 正确调用析构函数链
    
    // Base b;  // ❌ 错误！Base是抽象类
    return 0;
}
相关推荐
John_ToDebug5 小时前
Chromium回调机制的隐秘角落：当const &参数遇见base::BindOnce
c++·chrome·性能优化
消失的旧时光-19435 小时前
C++ 拷贝构造、拷贝赋值、移动构造、移动赋值 —— 四大对象语义完全梳理
开发语言·c++
cpp_25015 小时前
P8448 [LSOT-1] 暴龙的土豆
数据结构·c++·算法·题解·洛谷
MSTcheng.5 小时前
【C++】C++智能指针
开发语言·c++·智能指针
云深处@6 小时前
【C++11】部分特性
开发语言·c++
独望漫天星辰6 小时前
C++ 树结构进阶：从工程化实现到 STL 底层与性能优化
开发语言·c++
HellowAmy6 小时前
我的C++规范 - 鸡蛋工厂
开发语言·c++·代码规范
仰泳的熊猫6 小时前
题目1453:蓝桥杯历届试题-翻硬币
数据结构·c++·算法·蓝桥杯
rainbow68896 小时前
C++STL list容器模拟实现详解
开发语言·c++·list
热门推荐
01GitHub 镜像站点02Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services03openclaw配置教程（linux+局域网ollama）04UV安装并设置国内源05Linux下V2Ray安装配置指南06AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南07Claude Code Skills 实用使用手册08OpenClaw Chrome扩展使用教程 - 浏览器中继控制09Vue-skills的中文文档10openclaw使用nginx反代部署过程 与disconnected (1008): pairing required解决