C++类和对象知识点

1.类的定义

       目前所知有两种类定义的方法，Class 和 Struct，相比于c，c++的struct可以定义成员函数了。我们常用的类就是class。

1.1访问限定符

• C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限

选择性的将其接⼝提供给外部的⽤⼾使⽤。

• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访

问，protected和private是⼀样的，以后继承章节才能体现出他们的区别。

• 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有

访问限定符，作⽤域就到 }即类结束。

• class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

• ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。

1.2类域 

类定义了⼀个新的作⽤域，类的所有成员都在类的作⽤域中，在类体外定义成员时，需要使⽤ :: 作

⽤域操作符指明成员属于哪个类域。

2.实例化

2.1对象大小

内存对⻬规则

• 第⼀个成员在与结构体偏移量为0的地址处。

• 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。

•  对齐数为编译器默认的⼀个对⻬数与该成员⼤⼩的较⼩值。

• VS中默认的对⻬数为8

• 结构体总⼤⼩为：最⼤对⻬数（所有变量类型最⼤者与默认对⻬参数取最⼩）的整数倍。

• 如果嵌套了结构体的情况，嵌套的结构体对⻬到⾃⼰的最⼤对⻬数的整数倍处，结构体的整体⼤⼩

就是所有最⼤对⻬数（含嵌套结构体的对⻬数）的整数倍。

！！！ 如果结构体没有任何成员或只有成员函数（空类），大小为1字节占位表示对象存在

内存对齐的目的：编译器是不能在任意位置开始读取数据，而是从整数倍位置开始读，这样才能方便读取

后定义先析构 

3.this指针

编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this

指针。⽐如Date类的Init的真实原型为， void Init(Date* const this, int year,

int month, int day)

this指针存的就是这个类的地址

this指针不是存在对象里的

4.类的默认成员函数

默认成员函数在没有显式实现的情况下，编译器会自主实现，一个类主要有6个默认成员函数，这次我们主要讲前四个

4.1构造函数

就是用来实例化时初始化对象

1. 函数名与类名相同。

2. ⽆返回值。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

3. 对象实例化时系统会⾃动调⽤对应的构造函数。

4. 构造函数可以重载

#include<iostream>
using namespace std;
class Date
{
public:
// 1.⽆参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
// 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
// 3.全缺省构造函数
    /*Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }*/
    void Print()
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

Date d1; // 调⽤默认构造函数

Date d2(2025, 1, 1); // 调⽤带参的构造函数

Date d3();//但如果是这样调用，编译器就会分不清是函数声明还是实例化对象，就会报错

4.2析构函数

在需要销毁空间或栈帧的时候起作用

1. 析构函数名是在类名前加上字符 ~。

2. ⽆参数⽆返回值。 (这⾥跟构造类似，也不需要加void)

3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。

4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

后构造的先析构

4.3拷贝构造函数

注意：拷贝构造函数拷贝都是浅拷贝（一个一个字节的拷贝，如果是地址则拷贝地址，而不是内容），如果遇到stack类等，就会出现很多错误

比如下列代码的_a,如果是编译器自主实现的拷贝构造，则会将_a的地址拷贝到新的类中，这样在结束时，就会出现多次析构；并且在修改_a的内容时，由于是同一个地址，而不是同样的内容，修改其中之一就会导致另外一边不需要修改的内容被修改，非常麻烦

以下得显式实现相应代码

Stack(const Stack& st)
{
    // 需要对_a指向资源创建同样⼤的资源再拷⻉值
    _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
    if (nullptr == _a)
    {
        perror("malloc申请空间失败!!!");
        return;
    }
    memcpy(_a, st._a, sizeof(STDataType) * st._top);

    _top = st._top;
    _capacity = st._capacity;
}

1.拷⻉构造函数是构造函数的⼀个重载。

2. 拷⻉构造函数的参数只有⼀个且必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。

3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。

#include<iostream>
using namespace std;
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // 编译报错：error C2652: “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date”
    //Date(Date d)
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    Date(Date* d)
    {
        _year = d->_year;
        _month = d->_month;
        _day = d->_day;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

4.4赋值运算符重载 

4.4.1 运算符重载

以operator+加减乘除等符号进行重载，但不能对.*  ::  sizeof  ?:  .这5个运算符重载

如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算

符重载作为成员函数时，参数⽐运算对象少⼀个。

且重载运算符函数必须要有一个是类类型的形参

bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
    && d1._month == d2._month
    && d1._day == d2._day;
}

以上这种是不是成员函数时的例子

调用：d1 == d2 或 operator==(d1,d2);

bool operator==(const Date& d2)
{
    return _year == d2._year
    && _month == d2._month
    && _day == d2._day;
}

以上就是作为成员函数省略的一个形参

加上const防止被修改，加上&可以省去拷贝构造函数的调用（因为传值或传地址了）

4.4.2赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值

而拷⻉构造是⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。

// 传引⽤返回减少拷⻉
// d1 = d2;
Date& operator=(const Date& d)
{
// 不要检查⾃⼰给⾃⼰赋值的情况
    if (this != &d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    // d1 = d2表达式的返回对象应该为d1，也就是*this
    return *this;
}

返回值建议写为当前类的引用。return 可以返回*this

5.取地址运算符重载

5.1const成员函数

将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后

⾯，被const修饰的函数隐含的this指针从：

Date* const this 变为 const Date* const this

例如：

// void Print(const Date* const this) const
void Print() const
{
    cout << _year << "-" << _month << "-" << _day << endl;
}

 如果一个函数里没有什么值需要被修改，或者需要被维护，就用const保护起来

5.2取地址运算符重载

⼀般这两个函数编译器⾃动 ⽣成的就可以够我们⽤了，不需要去显⽰实现。

除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址

Date* operator&()
{
    return this;
 // return nullptr;
}
 const Date* operator&()const
 {
     return this;
 //  return nullptr;
 }

6.初始化列表

初始化列表是以跟在函数构造参数后：，为格式的初始化类成员的方式，后跟括号（括号内跟值或者表达式）初始化的顺序不依照初始化列表的顺序，而按照声明的顺序进行初始化

其中引用和const成员是必须在初始化列表初始化的

以下就是初始化列表常见问题

public:
    Date(int& x, int year = 1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    ,_t(12)
    ,_ref(x)
    ,_n(1)
    {
        // error C2512: “Time”: 没有合适的默认构造函数可⽤
        // error C2530 : “Date::_ref” : 必须初始化引⽤
        // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
    }

private:
    int _year;
    int _month;
    int _day;
    Time _t; // 没有默认构造
    int& _ref; // 引⽤
    const int _n; // const

7.类型转化

C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数

其实就是方便一点

!构造函数前⾯加explicit就不再⽀持隐式类型转换

class A
{
public:
    // 构造函数explicit就不再⽀持隐式类型转换
    // explicit A(int a1)

    A(int a1)
    :_a1(a1)
    {}
    //explicit A(int a1, int a2)
    A(int a1, int a2)
    :_a1(a1)
    ,_a2(a2)
    {}
    void Print()
    {
        cout << _a1 << " " << _a2 << endl;
    }

int main()
{
    A aa = 1;
    aa1.Print();    

    return 0;
}

8.static成员

• ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。

• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

• ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

• 静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。

• ⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

• 突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

• 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不⾛构造函数初始化列表。

静态成员不存放在对象，而是静态区，像函数析构这些相对于别的成员函数都是很后面才进行析构

#include<iostream>
using namespace std;
class A
{
public:
    A()
    {
        ++_scount;
    }
    A(const A& t)
    {
        ++_scount;
    }
    ~A()
    {
        --_scount;
    }
    static int GetACount()
    {
        return _scount;
    }
private:
    // 类⾥⾯声明
    static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
int main()
{
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetACount() << endl;
    cout << a1.GetACount() << endl;

    // 编译报错：error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明)
    //cout << A::_scount << endl;
    return 0;
}

9.友元

• 友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类

声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。

• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。

• 友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。

• ⼀个函数可以是多个类的友元函数。

• 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。

• 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。

• 友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是B的友元。

• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多⽤。

简单来说，友元可以帮助你访问你想访问的别的类的受保护的成员，但只能是单向的访问

class A
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
    int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

10.内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在

全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。

内部类默认是外部类的友元类

class A
{
private:
    static int _k;
    int _h = 1;
public:
    class B // B默认就是A的友元
    {
    public:

        void foo(const A& a)
        {
            cout << _k << endl; //OK
            cout << a._h << endl; //OK
        }
    };
};

int A::_k = 1;

11.匿名对象

顾名思义，就是⽤类型(实参) 定义出来的对象叫做匿名对象，简单来说就是不需要定义类名

匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象

class A
{
public:
    A(int n = 0):
    a(n)
    {}
    void Print()
    {
        cout<<a<<endl;
    }
private:
    int a;
};
int main()
{
    //只有一行代码生命周期
    A(3);
    cout<<A().Print();
    
    return 0;
}