Primer》第7章 类(二)"/>
《C++ Primer》第7章 类(二)
参考资料:
- 《C++ Primer》第5版
- 《C++ Primer 习题集》第5版
7.4 类的作用域(P253)
每个类都有自己的作用域,在类的作用域之外,普通的数据和函数成员只能由对象、引用或指针使用成员访问运算符访问,类型成员则通过作用域运算符访问。
作用域和定义在类外部的成员
对于定义在类外部的函数成员而言,一旦遇到类名,定义的剩余部分就是在类的作用域之内了,这就是为什么参数列表和函数体可以直接使用类的其他成员:
void Window_mgr::clear(ScreenIndex i){ // ScreanIndex是类Window_mgr中的类型成员Screen &s = screens[i];s.contents = string(s.height*s.width, ' ');
}
需要注意的是,由于返回类型出现在类名之前,所以它位于类的作用域之外,所以如果我们的返回类型是 ScreenIndex
,就必须写成 Window_mgr::ScreenIndex
。
7.4.1 名字查找与类的作用域(P254)
一般的**名字查找(name lookup)**过程比较直接:
- 在名字所在块中寻找声明语句。
- 如果没找到,继续查找外层作用域。
- 如果最终没有找到,则报错。
这里名字查找只考虑出现名字使用之前出现的声明
由于类的定义分两步处理:首先编译成员的声明,然后编译函数体。所以成员函数体可以使用类中的任何名字,而无需考虑这个名字是否在前面出现过。
用于类成员声明的名字查找
需要注意的是,只有成员函数体具有特殊性,成员函数的参数列表和返回类型仍然遵循一般名字查找的规则:
using Money = double;
string bal;
class Account{
public:Money balance() { return bal; } // 这里bal的类型是Money,Money是double的别名
private:Money bal;
};
类型名要特殊处理
如果类成员使用了某个名字,这个名字代表某种类型,则类不能再重新定义这个名字。
using Money = double;
class Account{
public:Money balance() { return bal; }using Money = double; // 错误,Money不能重新定义,即使与原定义一致也不行
};
需要说明是,某些编译器会忽略这个约定(比如 visual studio )。
成员定义中的普通块作用域的名字查找
成员函数体内的名字按照如下方式查找:
- 在函数内查找该名字,只有在使用之前出现的声明才被考虑。
- 如果在函数内没找到,则在类内查找,此时无需考虑先后顺序。
- 如果类内没找到,则在成员函数定义之前的作用域内寻找。
// 最好不要隐藏同名成员,这里仅作演示
pos height;
void Screen::dummy_fcn(pos height){cursor = width * height; // 参数中的heightcursor = width * this->height; // 类中的heightcursor = width * Screen::height; // 类中的heightcursor = width * ::height; // 全局变量height
}
在文件中名字的出现处对其进行解析
class X{void func(int);
};
int y;
void X::func(int i){i = y; // y的声明已经出现过了,所以可以正常使用
}
7.5 构造函数再探(P257)
7.5.1 构造函数初始值列表(P258)
如果没有在构造函数初始值列表中显式初始化成员,则该成员将在函数体之前执行默认初始化:
Sales_data::Sales_data(const string &s, unsigned cnt, double price){bookNo = s;units_sold = cnt;revenue = cnt * price;
}
上面这段代码相当于先默认初始化成员,然后再给成员重新赋值。
构造函数的初始值有时必不可少
如果成员是 const
、引用或某种没有定义默认构造函数的类类型,则必须将其初始化。
一旦构造函数体开始执行,初始化就完成了。
成员初始化的顺序
在构造函数初始值列表中,每个成员只能出现一次。构造函数初始值列表只说明用于初始化成员的值,而没有限定初始化的顺序。成员的初始化顺与它们在类定义中的出现顺序一致:
class X {int i;int j;
public:// 想用未定义的j初始化i,再用val初始化jX(int val):j(val), i(j) { }
};
默认实参和构造函数
class Sales_data {
public:Sales_data(string s = "") :bookNo(s) { }
};
如果一个构造函数为所有参数都提供了默认实参,则它实质上也定义了默认构造函数。
7.5.2 委托构造函数(P261)
C++11 新标准允许我们使用委托构造函数(delegating constructor)。委托构造函数使用本类中其他构造函数执行自己的初始化过程:
class Sales_data {
public:Sales_data(string s, unsigned cnt, double price) :bookNo(s), units_sold(cnt), revenue(cnt *price) { }// 委托构造函数Sales_data() :Sales_data("", 0, 0) { }Sales_data(string s) :Sales_data(s, 0, 0) { }// 先委托默认构造函数,然后默认构造函数在委托三参数构造函数// 执行完受委托的构造函数后再执行委托函数的函数体Sales_data(istream &is) :Sales_data() { read(is, *this); }
};
7.5.3 默认构造函数的作用(P262)
当类类型的对象被默认初始化或值初始化时自动执行默认构造函数。
使用默认构造函数
Sales_data obj1(); // 声明了一个函数
Sales_data obj2; // 使用默认构造函数
7.5.4 隐式的类类型转换(P263)
如果某个类类型定义了能通过一个实参调用的构造函数,则它实际上定了转换成此类类型的隐式转换机制,这种构造函数称作转换构造函数(converting constructor):
class Sales_data {
public:// 转换构造函数Sales_data(string s) :bookNo(s), units_sold(0), revenue(0) { }
};
void func(Sales_data x) { ; }string null_book = "9-999-99999-9";
func(null_book); // 正确
可以理解为用这个参数隐式构造一个临时量。
只允许一步类类型转换
func("9-999-99999-9"); // 错误,需要先将const char*转换成string,再由string转换成Sales_data
类类型转换不是总有效
以上面的代码为例,并不是所有的 string
都是我们需要的 bookNo
。
抑制构造函数定义的隐式转换
我们可以将构造函数声明为 explicit
来阻止隐式类型转换:
class Sales_data {
public:// 阻止隐式类型转换explicit Sales_data(string s) :bookNo(s), units_sold(0), revenue(0) { }
};
void func(Sales_data x) { ; }string null_book = "9-999-99999-9";
func(null_book); // 错误
只能在类内声明构造函数时使用 explicit
,不能在类外使用 explicit
。
explicit
构造函数只能用于直接初始化
Sales_data item1(null_book); // 正确
Sales_data item2 = null_book; // 错误
为转换显式使用构造函数
func(static_cast<Sales_data>(null_book)); // 正确
7.5.5 聚合类(P266)
当一个类满足如下条件时,它是聚合类(aggregate class):
- 所有成员都是
public
。 - 没有定义任何构造函数。
- 没有类内初始值。
- 没有基类,也没有
virtual
函数。
聚合类允许用户直接访问其成员,并且具有特殊的初始化形式:
struct Data {int ival;string s;
};Data val1{ 0, "hello" };
如上面的代码所示,我们可以用一个花括号括起来的初始值列表来构造聚合类,初始值的顺序必须与类中定义的顺序相同。如果初始值列表中的元素个数少于类的成员数量,则靠后的成员被值初始化。
7.5.6 字面值常量类
数据成员都是字面值类型的聚合类是字面值常量类;如果一个类不是聚合类,但它符合下述要求,则它也是字面值常量类:
- 数据成员都是字面值类型。
- 类必须至少有一个
constexpr
构造函数。 - 如果一个数据成员有类内初始值,这个初始值或是一条常量表达式,或是调用数据成员自己的
constexpr
构造函数。 - 类必须使用析构函数的默认定义。
constexpr
构造函数
前面提到,字面值常量类至少有一个 constexpr
构造函数。构造函数可以声明成 = default
。否则, constexpr
必须既满足构造函数的要求(不需要 return
语句),又满足 constexpr
函数的要求(唯一可执行语句就是返回语句)。综合上述两点可知,constexpr
构造函数体一般为空:
class Debug {
public:constexpr Debug(bool b = true) :hw(b), io(b), other(b) { }constexpr Debug(bool h, bool i, bool o):hw(h), io(i), other(o) { }constexpr bool any() { return hw || io || other; }
private:bool hw;bool io;bool other;
};
constexpr
构造函数必须初始化所有数据成员(有默认初始值的成员可以不显式初始化),初始值或者使用constexpr
构造函数,或者是一条常量表达式。
7.6 类的静态成员(P268)
有时候,类需要一些成员与类本身直接相关,而不是与类的各个对象保持关联。
声明静态成员
我们可以在成员的声明前加上关键字 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 double initRate();
};
类的静态成员存在于任何对象之外,所以每个 Account
对象将包含两个数据成员 owner
、amount
。interestRate
对象只有一个,并被所有对象共享。静态函数成员也不与任何对象绑定在一起,所以不包含 this
指针,也不能声明成 const
。
使用类的静态成员
可以使用作用域运算符直接访问静态成员:
double r;
r = Account::rate();
尽管静态成员不属于类的某个对象,但我们仍然可以通过类的对象、引用或指针来访问静态成员。
成员函数不通过作用域运算符也能直接使用静态成员:
class Account {
public:void calculate() { amount += amount * interestRate; }
private:static double interestRate;
}
定义静态成员
在类外部定义静态成员时,不能出现 static
关键字,static
只能出现在类内部的声明语句。
由于静态数据成员不属于类的任何一个对象,所以它们不是在创建类的对象时被定义的,也不是由构造函数初始化的。
一般来说,我们通常在任何函数外部定义和初始化静态成员:
double Account::interestRate = initRate();
由于见到 Account
后就知道当前处在类的作用域,所以后面调用 initRate()
不需要作用域运算符;同函数成员在类外部定义一样,interestRate
的定义也可以访问类中的私有成员。
静态成员的类内初始化
前面提到,类的静态成员不应该在类内初始化。但我们可以为静态成员提供 const
整数初始值(似乎没有这个要求?),但是要求静态成员必须是字面值常量类型 constexpr
且初始值必须是常量表达式。
class Account {
private:static constexpr int period = 30;double daily_tbl[period];
};
尽管一个常量静态数据成员已经在类内部初始化了,我们通常还是要在类外部定义一下这个成员,此时不能再指定初始值:
constexpr int Account::period;
静态成员能用于某些场景,而普通成员不能
静态数据成员可以是不完全类型,比如它本身所属的类类型:
class X{
public:static X mem1; // 正确X mem2; // 错误
};
此外,我们可以使用静态成员作为函数成员的默认实参。
更多推荐
《C++ Primer》第7章 类(二)
发布评论