当前位置：首页 > news >正文

2025.3.1有关c++类的学习

news 来源：原创 2025/5/14 11:29:25

初始化列表

首先看传统的初始化


    Person(int a, int b, int c)
    {
        m_A = a;
        m_B = b;
        m_C = c;
    }

再看初始化列表的方式来初始化属性

class Person  
{  
public:  
    //初始化列表初始化属性  
    Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c)  
    {  
  
    }  
  
    int m_A;  
    int m_B;  
    int m_C;  
};

这个代码表示Person这个构造函数接受abc三个变量，分别把它们赋值给m_A,m_B,m_C

类对象作为类成员

这个涉及到的问题是构造函数和析构函数的调用顺序问题：
结论:当一个类中的成员变量是另外一个类的时候，会先调用成员变量中另一个类的构造函数，再调用它本身的构造函数。析构函数则是相反的顺序.
下面看例子
这是一个C++的代码，我们创建了一个人类，里面的成员变量包括人的名字和它的手机名字

//人类  
class Person  
{  
public:  
    Person(string name, string P_Name) : m_Name(name), m_Phone(P_Name)  
    {  
        cout << "人类构造函数的调用" << endl;  
    }  
    ~Person()  
    {  
        cout << "人类析构函数的调用" << endl;  
    }  
    //姓名  
    string m_Name;  
    //手机名  
    Phone m_Phone;  
};

所以呢，我们还要创建一个手机类，里面封装着手机的品牌名称

//手机类  
class Phone  
{  
public:  
    Phone(string name) : m_Name(name)  
    {  
        cout << "手机类构造函数的调用" << endl;  
    }  
    ~Phone()  
    {  
        cout << "手机类析构函数的调用" << endl;  
    }  
    //手机品牌名称  
    string m_Name;  
};

最后的运行结果为：

手机类构造函数的调用
人类构造函数的调用
张三拿着华为
人类析构函数的调用
手机类析构函数的调用

进程已结束，退出代码为 0

由此印证了结论

静态成员变量

静态成员变量的三个特性：
1 静态成员变量在编译阶段就分配内存了
2 静态成员变量不属于任何一个对象由所有对象共享
3 静态成员变量在类内声明在类外初始化
注意静态成员变量也是有访问权限的

this 指针的使用

解决同名冲突

class Person
{
public:
    Person(int age)
    {
        //this指向被调用的成员函数所属的对象
        this->age = age;
    }
    Person AddPerson(Person & p)
    {
        this->age += p.age;
        return *this;
    }
    int age;
};
void test01()
{
    Person p1(18);
    cout << "p1 的年龄为：  " << p1.age << endl;
}

int main()
{
    test01();
    return 0;
}

如果没有this，打印的结果不会是18，因为存在同名冲突age并没有赋值给成员变量age，加了this之后才可以。

返回值为* *this

class Person
{
public:
    Person(int age)
    {
        //this指向被调用的成员函数所属的对象
        this->age = age;
    }
    Person AddPerson(Person & p)
    {
        this->age += p.age;
        return *this;
    }
    int age;
};

//2.返回对象本身用*this
void test02()
{
    Person p1(10);

    Person p2(10);

    //链式编程思想
    p2.AddPerson(p1).AddPerson(p1);

    cout << "p2的年龄为：" << p2.age<< endl;
}
int main()
{
//    test01();
    test02();
    return 0;
}

注意函数返回的不是p2本身。每次返回都是一个新的对象，所以没有叠加
如果返回的形式为Person&那么返回的就是它本事，利用链式的特性可以进行叠加

常函数与常对象

#include <iostream>
using namespace  std;
class Person
{
public:
    //this指针的本质 是指针常量 指针的指向是不可以修改的
    //const Person * cosnt this
    //在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
    void showPerson() const//加上这个const之后，this指针指向的值也不可以修改了
    {
        this->m_B = 100;
        //this->m_A = 100;
        //this = NULL; //this指针不可以修改指针的指向
    }

    void func()
    {

    }
    int m_A;
    mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值
};
void test01()
{
    Person p;
    p.showPerson();
}
void test02()
{
    const Person p;
    //p.m_A = 200;
    p.m_B = 300;//m_B是特殊值，在常对象下也可以修改

    //常对象只能调用常函数
    p.showPerson();
    //p.func(); //常对象 不可以调用普通成员函数
}
int main()
{
    return 0;
}

在上述代码中，我们可以得出如下结论：
1 this指针不可以修改它的指向但是可以修改它指向的值
2 在成员函数后面加上const修饰的this指针指向的值，此时this指向的值不可以修改，这就是为什么在常量函数中不可以修改m_A的值，却可以修改特殊类型m_B的值。
特殊类型为：mutable
3 常对象只能调用被const修饰的常函数而不可以调用普通函数，所以在test02中调用p.func()会报错。而调用showPerson这个常函数却不会报错。

友元

全局函数做友元

写法在类的开头加上frien “你要作为友元的全局函数的声明”
请看如下代码：

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

class Building
{
    friend void goodGay(Building * building);
public:
    Building()
    {
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
public:
    string m_SittingRoom;
private:
    string m_BedRoom;//卧室
};
//全局函数
void goodGay(Building * building)
{
    cout << "好基友全局函数正在访问：" << building->m_SittingRoom << endl;
    cout << "好基友全局函数正在访问：" << building->m_BedRoom << endl;
}
void test01()
{
    Building building;
    goodGay(&building);
}
int main()
{
    test01();

    system("pause");
    return 0;
}
```cpp