C++基础的不能再基础的学习笔记——类（二）

最新推荐文章于 2024-08-29 15:50:05 发布

原创最新推荐文章于 2024-08-29 15:50:05 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

19 篇文章

订阅专栏

本文深入探讨了C++中的类概念，包括自定义类型别名、可变数据成员、内联函数及数据成员初始化等内容。同时，还详细介绍了构造函数的使用技巧，例如构造函数初始值列表、委托构造函数以及隐式类类型转换等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

类

在上一章中http://blog.youkuaiyun.com/fancynece/article/details/79143021，
我们了解了类的一些基础知识，接下来，对类做进一步的探究。

一、类成员再探

1. 自定义类型别名

在类中，我们可以为数据类型定义别名而使代码更清晰简洁。

class Screen {
public:
    typedef string::size_type pos; //pos是string::size_type类型的别名 
private:
    pos cursor = 0;             //光标位置
    pos height = 0, width = 0;  //屏幕高、宽
    string contents;            //屏幕内容
};

在上述代码段中，pos是string::size_type类型的别名。将它设置为public是因为，这样在类外也可以使用pos。

2. 可变数据成员

可变数据成员永远不是const，不论是const函数还是const对象，它都是可以修改的。由关键字mutable修饰。

mutable size_t access_ctr;    

void some_member() const { access_ctr++; };

其中，access_ctr为可变数据成员，用以追踪每个对象的函数被调用了多少次，可见，即使成员函数为const函数，依然可以改变它的值。

3. 小问题

① 关于内联函数，只要在声明或定义任一处以关键字inline修饰，即为内联函数

② 数据成员初始值

class Window_mgr {
private:
    vector<Screen> screens{ Screen(21,20,' ') };
};

类内数据成员赋初值，必须以 = 或者 { }表示。

二、构造函数再探

1. 构造函数初始值列表

Person(string s, int a, bool se) : name(s), age(a), sex(se) {};

Person(string s, int a, bool se) { name = s; age = a; sex = se; };

上述代码中的两个构造函数，虽然使得数据成员的值相同，但是有很大区别。

第一个函数是初始化数据成员，第二个函数是对数据成员进行赋值。对于底层而言，第一个函数直接初始化，第二个函数先初始化再进行赋值。

并且，当数据成员含有 (1) const和引用 (2) 无默认构造函数的类的对象 时，是必须要对数据成员进行初始化的，此时只能通过构造函数初始值列表的方式。

另外我们需要注意的是，构造函数初始值列表中数据成员出现的顺序，并不会影响初始化的顺序，数据成员初始化顺序是它们的声明顺序。

2. 委托构造函数

C++11新标准提供了委托构造函数，使用其他构造函数执行初始化。

格式为：类名(参数列表1) : 类名(参数列表2) { 函数体 }; 冒号前的构造函数将自己的初始化任务委托给冒号后的构造函数。


Person(string s, int a, bool se) : name(s), age(a), sex(se)
{ 
    cout << "1" << endl; 
}; 

Person(string s) : Person(s,0,0) 
{ 
    cout << "2" << endl; 
};

Person fancy("MaYun");

/*
屏幕输出为：
1
2
*/

执行上述代码的步骤为

使用Person(string s)构造函数初始化对象fancy
它是一个委托构造函数，因此转而执行Person(“MaYun,0,0)，按初始值列表初始化，之后执行函数体
该构造函数执行完毕后，再回来执行Person(string s)的函数体

3. 隐式的类类型转换

① 什么是隐式的类类型转换

转换构造函数：只含有一个形参的构造函数，可以完成 该形参类型—>类类型 的隐式类型转换。

因此，当我们使用类类型时，可以用该形参类型进行代替，因为有隐式转换规则。

Person(string s) : name(s) { }; //定义了从string到Person的类型转换
void GetPerson(Person& p);    //形参为Person类型


Person fancy("MaYun");
string temp = "LLLLLLL";
fancy.GetPerson(temp);   //实参为string类型

在上述代码中编译器会自动完成temp到Person类型的转换，生成一个临时的Person对象。

同样的，编译器只会自动执行一步类型转换。若上述代码为fancy.GetPerson("LLLLLLL");就是错误的，要完成”LLLLLLL”到string的转换，以及string到Person的转换。

② 抑制隐式的类类型转换

我们可以通过将转换构造函数声明为explicit，使它不定义隐式的类型转换。

explicit Person(string s) : name(s) { };   

Person fancy("MaYun");    //正确，直接初始化
Person sixday = "XiaoGenBan";   //错误，拷贝初始化

需要注意的是，explicit只能在声明时出现，并且被定义为explicit的函数，只能用于直接初始化，不可拷贝初始化。

三、类的静态成员

1. 什么是静态成员？

有的时候，类需要 与类本身相关，与各个对象无关的成员，这时需要关键字static来声明。

如下为一个银行账户记录类，由于基准利率与每个账户记录无关，但是又与账目相关，因此我们将基准利率声明为静态。

class Account {
public:
    void calculate() { amount += amount * interestRate; };
    static double rate() { return interestRate; };
    static void rate(double);
private:
    string owner;
    double amount;

    static double interestRate;
    static constexpr int period = 30;

    static double initRate();
};


double Account::interestRate = initRate();
constexpr int Account::period;

类的静态成员存在于任何对象之外，只有一个且被所有对象共享。

在上述代码段中，Account类有三个数据成员owner，amount，interestRate，但是对于每个对象而言，只有owner，amount两个数据成员。

同样的，对于静态函数而言，它不属于某个对象，因此不存在this指针，也就不能声明为const函数（const是用来修饰this指针的）。
静态函数可以定义在类内和类外，但static关键字只可出现在类内声明。
静态数据成员必须在类外初始化。

静态数据成员不属于任何对象，因此不是在创建对象时定义的，不是由构造函数进行初始化的，而我们必须在类外对其进行初始化，因此一旦被定义，它将存在于程序的整个生命周期。如上述代码中的interestRate。

然而，存在类内初始化的数据成员，我们称其为常量静态数据成员，它必须为const整数类型，而一般在用到该数据成员时，也必须在类外声明一下。如上述代码中的period。

2. 使用类的静态成员

① 通过作用域运算符直接访问

cout << Account :: rate();

② 通过对象访问

Account a;
cout << a.rate();

3. 静态成员能用于非静态成员不能用于的情况

静态成员可以是不完全类型（声明之后定义之前）。更为重要的是，可以是该类类型本身。

class brid{
    static brid a; //正确

    brid& b;       //正确
    brid* c;       //正确
    brid  d;       //错误
};