c++primer类详解

时间：2022-11-10 22:12:48

类的基本思想是数据抽象和封装。

数据抽象是依赖接口和实现分离的编程技术。

1. 定义抽象数据类型

1.1 设计Sales_data类

  • 成员函数的声明必须在类内部，定义可以在内部或外部
  • 作为接口的非成员函数，如print、read，声明定义都在类的外部。
  • 定义在类内部的函数都是隐式的inline函数
  • 调用一个成员函数时，隐式初始化this指针
  • 任何自定义名为this的参数或者变量都是非法的
  • const成员函数
    •  const成员函数：在参数列表后加上const关键字的函数
    • const的作用是修改隐式this指针的类型
    • 默认情况下，this的类型是指向类型非常量的常量指针。因此，不能将this绑定在一个非常量对象上(不能把this绑定到其他对象)，所以也不能在常量对象上调用普通成员函数（不能用const 对象访问普通成员函数）。
    • const成员函数提高了函数灵活性
  • 常量对象，以及常量对象的引用或指针只能调用常量成员函数。
  • 编译器分两步处理类。
    • 1.编译成员声明。
    • 2.所有成员声明编译完后，编译成员函数体。因此，成员声明出现在成员函数体后，编译器也可以正常编译
  • 在类外定义函数体
    • 需要在函数名前加上类名::，在类名之后剩余的代码位于作用域之内
    • 若返回类型也是在类内声明的，就需要在函数名和返回类型前都加上类名::。
    • 若在类内声明成了const成员函数，在外部定义时，const关键字也不能省略。
  • 若需要返回类本身，使用return *this 

1.2 定义类相关的非成员函数

  • 类相关非成员函数：属于类的接口，但是不属于类本身。
  • 通常把函数声明和定义分开。和类声明在同一头文件内。
  • 通常情况下，拷贝一个类其实是拷贝其成员。（若想拷贝执行其他操作，查阅拷贝赋值函数）
?
1
2
Sale_data s1;
Sale_data s2=s1;//s2拷贝了s1的成员

1.3构造函数

  • 构造函数的任务是初始化类对象的数据成员
  • 只要类对象被创建，一定会执行构造函数
  • 构造函数名与类名相同，并且没有返回类型，其他与普通函数相同。
  • 构造函数不能声明成const
  • 默认构造函数
    • 默认构造函数无需任何实参
    • 若没有为类显式定义任何构造函数，编译器隐式构造一个合成的默认构造函数。
    • 合成的默认构造函数按照如下规则初始化类成员
      • 若存在类内初始值，用它来初始化成员
      • 否则，默认初始化成员
    • 某些类不能依赖合成的默认构造函数
      • 若类包含内置类型或复合类型成员，只有当这些值全被赋予了类内初始值时，这个类才适合使用合成的默认构造函数。
      • 若类a包含一个成员类b，若b没有默认构造函数，则编译器无法为a构造正确的默认构造函数
      • 若定义了其他构造函数，则编译器不会构造默认初始函数
?
1
2
3
4
5
6
7
class A{
//定义了一个实参为string的构造函数
//此时，编译器不会合成默认构造函数
    A(std::string a){}
}
A a;//错误，没有默认构造函数
A a1(std::string("小黑"));//只能用string参数
  • 参数列表后加上 =defualt表示要求编译器生成默认构造函数
  • =defualt可以和声明一起出现在类内，也可以作为定义出现在类外。

若在类内部，则默认构造函数时内联的，若在类外部，默认不是内联的。

?
1
2
3
4
class A{
    A()=defualt;
}
A a;//正确，编译器生成默认构造函数
  • 构造函数初始值列表
    • 存在编译器不支持类内初始值，这样的话默认构造函数不适用（因为默认构造函数使用类内初始值初始化类成员），这时应该使用构造函数初始值列表。
    • 函数初始值列表是参数列表如下所示（冒号以及冒号和花括号间的代码::bookNo(s)）
    • 构造函数不应该轻易覆盖掉类内初始值，除非新赋的值与原值不同在
    • 构造函数的过程中，没有出现在函数初始化列表中的成员将被执行默认初始化
?
1
2
3
4
5
6
7
class Sales_data{
    Sales_data(const std::string &s,unsigned n,double p):
    bookNo(s),units_sold(n),revenue(p*n){}
    //当编译器不支持类内初始值时，可用如下方法定义
    Sales_data(const std::string &s):
    bookNo(s),units_sold(0),revenue(0){}
}
  • 在类外部定义构造函数,要声明是哪个类的构造函数，在函数名前加上类名::
?
1
2
3
Sales_data::Sales_data(std::istream cin){
    read(cin,*this);
}

1.4 拷贝、赋值和析构

  • 编译器会为类合成拷贝、赋值和销毁操作。
  • 编译器生成的版本对对象的每个成员执行拷贝、赋值和销毁操作

2 访问控制和封装

  • 访问说明符

public说明符后的成员在整个程序内可以被访问

private说明符后的成员可以被类的成员函数访问

  • 一个类可以包含0个或多个访问说明符，有效范围到下一个说明符出现为止。
  • class和struct关键字定义类的唯一区别是
    • class在第一个访问说明符出现之前的区域默认是private
    • struct在第一个访问说明符出现之前的区域默认是public

2.1 友元

  • 类可以允许其他类或函数访问他的非公有成员。方法是用关键字friend声明友元。
  • 友元的声明只能在类内部
  • 友元声明的位置不限，最好在类定义开始或结束前集中声明友元。
  • 封装的好处
    • 确保用户代码不会无意间破坏封装对象的状态
    • 被封装的类的具体实现细节可以随时改变
  • 友元在类内的声明仅仅指定了访问权限，并不是一个通常意义的函数声明
    • 若希望类的用户能够调用某个友元函数，需要在友元声明之外再专门对函数进行一次声明
    • 为了使友元对类用户可见，友元声明与类本身防止在同一个头文件中
    • 一些编译器强制限定友元函数必须在使用之前在类的外部声明

2.2 类的其他特性

接下来介绍：类型成员、类的成员的类内初始值、可变数据成员、内联成员函数、从成员函数返回*this、如何定义使用类类型、友元类

2.2.1 类成员再探

  • 类别名（类型成员）：

 在类中定义的类型名字和其他成员一样存在访问限制，可以是public或者private

类别名必须先定义后使用

（回忆：类成员变量可以在类成员函数之后定义，但是在类函数中使用，原因是编译器先编译类成员变量后边一类成员函数）

类型成员通常出现在类开始的地方

?
1
2
3
4
5
class Screen{  
    public:
    //等价于 using pos = std::string::size_type
    typedef std::string::size_type pos;
}
  • 令成员作为内联函数

定义在类内部的函数是自动inline的，定义在类外部的函数，若需要声明内联函数，要加上inline;inline成员函数也应该和相应的类定义在同一个头文件夹

?
1
2
3
4
5
6
inline
Screen& Screen::move(pos r,pos c){
    pos row = r*width;
    cursor = row + c;
    return *this;
}
  • 可变数据成员，永远不会是const，即使他是const对象的成员
?
1
2
3
4
5
6
7
8
class Screen{
public void some_member() const;
private:
    mutable size_t access_ctr;//使用mutable声明可变数据成员
}
void Screen::some_member() const {
    ++access_ctr;//即使在const成员函数中，仍然可以修改可变数据成员
}
  • 类内初始值使用=的初始化形式或者花括号括起来的直接初始化形式

2.2.2 返回*this的成员函数

  • 注意返回类型是否是引用。是否是引用对函数的使用方法影响很大
?
1
2
3
4
5
6
7
8
9
10
11
12
inline Screen &Screen::set(char ch){
    content[cursor] =ch;
    return *this;
}
inline Screen &Screen ::move(pos r,pos col){
    cursor= r * width + col ;
    return *this;
}
Screen s(3,2,'');
//move函数返回s本身，所以可以接着调用set函数
//并且move函数返回的是Screen的引用，若返回的不是引用，则会返回一个新的Screen对象
s.move(3,2).set('!');
  • 从const函数返回的是常量引用，在const函数中无法修改类成员变量
  • 使用const函数进行重载

编写函数display打印Screen中的contents，因为只是展示，不需要修改值，所以这应该是一个const函数。

但是希望实现在展示后，能移动光标：s.display().move(2,3)。这要求display返回的值是可以修改的，所以这不应该是const函数。

基于const重载，可以根据Screen对象是否是const来进行重载。

  • 建议多使用do_display这类函数完成实际工作，使公共代码使用私有函数
    • 可以集中修改
    • 没有额外开销
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Screen{
public:
    Screen* display(std::ostream &os){
        do_display(os);
        return *this;
    } 
    const Screen* display(std::ostream &os) const{
        do_display(os);
        return *this;
    }
private:
    void do_display(std::ostream &os) const{
        os<<content;
    }
}
int main(){
    const Screen cs(3,3,'!');
    Screen s(3,3,'.')
    cs.display();//因为cs是const的，调用第二个const函数
    s.display();//调用第一个非const的函数
}

2.2.3 类类型

  • 每个类定义了唯一的类型，即使成员完全相同，也是不一样的类。
?
1
2
3
4
5
6
7
8
class A{
int member;
}
class B{
int member;
}
A a;
B b = a;//错误！！
  • 不完全类型
    • 类似于函数，类也可以只声明，不定义,这被叫做不完全类型
    • 不完全类型是向程序说明这是一个类名
    • 不完全类型使用环境很有限，只是可以定义指向这种类型的指针或引用，声明（但不能定义）以不完全类型作为参数或返回类型的函数。
  • 类在创建前必须被定义
  • 类的成员不能有类本身（除了后面介绍的static类），但是可以是指向自身的引用或指针

2.2.4 友元再探

  •  一个类制定了其友元类，则友元函数可以访问该类的所有成员
  • 友元关系不存在传递性
  • 每个类自己负责控制自己的友元类或友元函数
    • 定义友元函数的顺序：

有一个screen类，有私有成员content；

有clear函数，可以清除content的内容。

1.先声明clear函数

2.在screen类中将clear函数函数定义为友元函数

3.定义clear函数，使用screen类

  • 定义友元类

有类window，window有私有成员content；友元类 window_mgr需要直接操作content。

  •  正常编写window类，在window类中声明：friend class window_mgr；
  • 正常编写 window_mgr类，可以直接使用window的content
  • 注意将类写在头文件中，要按照如下格式；否则编译会报错重复的类定义
?
1
2
3
4
#ifndef xxx_H
#define xxx_H
/class 定义///
#endif
  • 一个类想把一组重载函数定义为它的友元，需要对这组函数中的每一个进行友元声明。
  • 友元声明仅仅表示对友元关系的声明，但并不表示友元这个函数本身的声明
?
1
2
3
4
5
6
7
8
9
10
struct X{
    friend viod f(){/*友元函数可以定义在类的内部，但是我认为这样没有意义*/
    X(){f();}//错误，f还没有被定义
    void g();
    void h();
    }
    void X::g(){ return f();}//错误，f还没有被定义
    void f();
    void X::h(){return f();}//正确，f的声明已经在定义中了
};

2.4 类的作用域

  • 定义在类外的方法需要在方法名前使用::说明该方法属于哪一个类，在说明属于的类后，该函数的作用域位于该类内。
    • 即返回类型使用的名字位于类的作用域之外。若返回类型也是类的成员，需要在返回类型前使用::指明返回类型属于的类
?
1
2
3
4
5
//pos的类型声明在window类中，并且返回类型在类的作用域外，因此要使用window::pos
window::pos window::get_pos(){
//在window::get_pos后的所有代码作用域在类内，所以返回cursor，相当于this->cursor
return cursor;
}

2.4.1 名字查找和类的作用域

  • 类的定义分两步处理
    • 1.编译成员的声明
    • 2.直到类成员全部可见后编译函数体
  • 一般来说，内层作用域可以重新定义外层作用域名字；但在类中若使用了某个外层作用域中的名字，并且该名字表示一种类型，则类不能在之后重新定义该名字
?
1
2
3
4
5
6
7
8
typedef double Money;
class Acount{
public:
    Money balace(){return bal;}//使用外层定义的Money
private：
    typedef double Money;//错误，不能重新定义Money
    Money bal;
}
  • 类型名的定义通常出现在类的开始处，来确保所有使用该类型的成员都出现在定义之后；
  • 类中同名变量会被隐藏，但是可以用this指针访问成员变量
?
1
2
3
4
5
6
7
8
9
double height;
class Window{
    double height;
}
void Window::dummy_fcn(double height){
    double class_height = this->height;
    double para_height = height;
    double  global_height = ::height;
}

2.5 构造函数再探

2.5.1

  • 构造函数初始值列表 在类的有引用成员和const成员时，必须在构造函数中使用初始值列表进行初始化
  • 建议养成使用构造函数初始值的习惯
  • 初始值列表只说明初始值成员的值，并不限定初始值的具体执行顺序；初始值顺序与他们在类定义中的出现顺序一致（某些编译器在初始值列表和类中顺序不一致时，会生成一条警告信息）
?
1
2
3
4
5
6
//示例危险操作
strcut X{
//实际上按照声明顺序初始化，先初始化rem时，base的值未知
X(int i,int j):base(i),rem(base%j){}
int rem,base;
}
  • 建议，使用初始值列表和类中变量顺序一致，可能的话，尽量避免使用某些成员初始化其他成员。

2.5.2 委托构造函数

  • 成员初始值列表的唯一入口是类名，可以用构造函数可以调用其他构造函数，调用过程应该写在初始值列表位置
?
1
2
3
4
5
class Sale_data{
public:
    Sales_data(const std::string &s,unsigned s_num,double price):units_sold(s_num),revenue(s_num*price),BookNo(s){}
    Sales_data():Sales_data("",0,0){}//委托给上一个构造函数
}

2.5.3 默认构造函数的作用

  • 当对象被默认初始化或值初始化时执行默认构造参数
  • 默认初始化发生在：

 1.块作用域内不使用任何初始值定义的一个非静态变量或者数组时

2.类本身含有类类型的成员且使用合成的默认构造函数

3.类类型成员没有在构造函数初始值列表中显式初始化时

  • 值初始化发生在：

1.初始化数组时，提供的初始值数量少于数组大小

2.不使用初始值定义一个局部变量时

3.书写形如T()的表达式显式请求值初始化时，其中T是类型名。如vector接受一个实参说明vector的大小

  • 若定义了其他构造函数，编译器不在生成默认构造函数，因此最好需要我们程序员来提供一个构造函数

2.5.4 隐式的类类型转换

  • 转换构造函数：能够通过一个实参调用的构造函数定义一条从构造函数的参数构造类型向类类型转换的规则。
?
1
2
3
vector<string> str_vec;
//需要push一个string，但传参一个字符串。这里使用了string的转换构造函数
str_vec.push_back("小黑~");
  • 转换构造函数只允许一步构造转换
  • 需要多个参数的构造函数无法执行隐式转换
?
1
2
3
4
5
6
//Sales_data有参数为string的构造函数
//Sales_data的combine为方法：
//Sales_data & Sales_data::combine(const Sales_data& );
Sales_data item;
item.combine("无限~")//错误，只允许一步构造
item.combine(string("无限~"))//正确，只有string到Sales_data的一步隐式构造转换
  • 使用explicit抑制构造函数定义的隐式转换
?
1
2
3
4
5
class Sales_data{
explicit Sales_data(const string&):bookNo(s){};
...//其他声明
}
item.combine(string("无限~"));//错误，explicit阻止了隐式转换

explicit函数只能用于直接初始化

?
1
2
3
4
//Sales_data的构造函数：explicit Sales_data(const string&):bookNo(s){};
string bookNo = "001";
Sales_data item1(bookNo);//正确，直接初始化
Sales_data item2 = bookNo;//错误，拷贝初始化

尽管编译器不会将explicit的构造函数用于隐式转换过程，但是可以使用显式强制转化

?
1
2
3
string bookNo ="001";
item.combine(bookNo);//错误，explicit阻止了隐式转换
item.combine(static_cast<Sales_data>(bookNo));//正确，强制转换

2.5.5 聚合类

  • 聚合类的定义。一个满足下列条件的类被称为聚合类

1.所有成员都是public的

2.没有定义任何构造函数

3.没有类内初始值

4.没有基类，也没有virtual函数

  • 可以使用{}括起来的成员初始值列表来初始化聚合类
?
1
2
3
4
5
6
7
class Data{
public:
    int ival;
    string s;
    }
//顺序一定相同
Data val1={0,"孔子"};    

2.5.6 字面值常量

  • constexpr函数的参数和返回值必须是字面值类型
  • 字面值类型包括：算术类型、指针、引用、数据成员都是字面值类型的聚合类和满足下面条件的类。

1.数据成员都是字面值类型

2.类必须含有一个 constexpr构造函数

3.使用默认定义的析构函数

4.如果一个数据成员含有类内初始值，则该初始值必须是一条常量表达式；如果数据成员属于某种类类型，则初始值必须使用自己的constexpr构造函数

  • 构造函数不能是const的，但是可以是constexpr的。
  • 字面值常量类，至少提供一个constexpr构造函数
  • constexpr构造函数
    • 是构造函数，没有返回语句
    • 是 constexpr函数，唯一可执行语句就是返回语句
    • 所以constexpr构造函数函数体为空，只能通过初始化列表值来执行构造初始化
?
1
2
3
4
5
6
7
class Data{
public:
    constexpr Data(int para_i,string para_s):ival(para_i),s(para_s){}
    int ival;
    string s;
    }
constexpr Data data(1,"吃烤肉");

1.6 类的静态成员

  • 使用static在类中声明静态成员，该静态成员和类关联，而不是和类对象关联
  • 静态成员函数也不与任何类对象绑定起来，并且静态成员函数不含this指针。（包括this的显式调用和对非静态成员的隐式调用）
  • 在外部定义static函数时，不能重复static，static关键字出现类内部的声明语句
  • 不能在类内部初始化静态成员，必须在类的外部定义和初始化每个静态成员，因此一旦被定义，就一直存在在程序的整个生命周期
  • 想要确保对象只定义一次，最好的办法就是把静态数据成员的定义和其他非内联函数的定义放在同一个文件
  • 静态成员的类内初始化
    • 一般情况下， 类的静态成员不应该在类的内部初始化
    • 静态成员必须是字面值常量类型（constexpr）
    • 即使一个常量静态数据成员在类的内部初始化了，通常也应该放在类的外部定义一下该成员（这样才能使生命周期直到程序结束）。
  • 静态成员的特殊使用场景
    • 静态数据成员的类型可以就是它所属的类型
?
1
2
3
4
5
6
7
8
class Bar{
public:
//...
provite:
    static Bar mem1;//正确，static成员可以是不完整类型
    Bar* mem2;//正确，指针成员可以是不完整类型
    Bar mem3;//错误
}
?
1
- 静态成员可以作为默认实参
?
1
2
3
4
5
6
class Screen{
    public:
    Screen& clear(char = bkground)
    private:
    static const char bkground;
}

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!

原文链接：https://blog.csdn.net/qq_36183881/article/details/119854348

标签：

相关文章