类与对象 ---C++三大特性之封装

于 2021-11-11 20:06:54 发布
阅读量528 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48565202/article/details/121275091
版权

类与对象

文章目录

1. 面向面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

由于C++早期产生是基于C语言的，造成它不是纯面向对象，C++进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，以及面向对象的程序设计（只能说基于面向对象）。

2. 类的引用

C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

struct Student
{
    void SetStudentInfo(const char* name, const char* gender, int age)
    {
        strcpy(_name, name);
        strcpy(_gender, gender);
        _age = age;
    }
    void PrintStudentInfo()
    {
    	cout<<_name<<" "<<_gender<<" "<<_age<<endl;
    }
    char _name[20];
    char _gender[3];
    int _age;
};

int main()
{
    Student s;
    s.SetStudentInfo("Peter", "男", 18);
    return 0;
}

上面结构体的定义，在C++中更喜欢用class来代替。

3. 类的定义
class className
{
	// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。
类中的元素称为类的成员：类中的数据称为类的属性或者成员变量;

​ 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

  1. 声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处
    理。

  2. 声明放在.h文件中，类的定义放在.cpp文件中

    一般来说我们采用第二种声明和定义分开的方式，但要注意的是在.h文件中要加上类名（作用域），否则编译器会报错。

4. 类的访问限定符及封装
4.1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

image-20211017174217688

【访问限定符说明】

  1. public修饰的成员在类外可以直接被访问

  2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)

  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

  4. class的默认访问权限为private，struct为public(因为struct要兼容C)

    注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

那么问题来了：C++中的struct和class的区别是什么？

C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。

4.2 封装

【面试题】 面向对象的三大特性：封装、继承、多态。（抽象、反射（C++没有，Java有））
在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理，不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。

在C语言中，我们可以随便访问数据和方法，比较自由。但是这就需要我们有良好的素养，懂得规范，恪守规则。但是总有一些不懂规矩及不守规则的人，所以在C++中出现封装的定义，强制我们恪守规则，并且保护数据安全。

5. 类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

一个类就有一个作用域。

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;	
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout<<_name<<" "_gender<<" "<<_age<<endl;
}
6. 类的实例化

用类类型创建对象的过程，称为类的实例化。

  1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
  2. 一个类可以实例化出多个对象，**实例化出的对象占用实际的物理空间，存储类成员变量，**在这里类的声明并没有开空间，在类的实例化时才开空间，与是否初始化是否无关。
  3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

image-20211017180051881

7. 类对象模型
7.1 计算类对象的大小
class A
{
public:
void PrintA()
{
	cout<<_a<<endl;
}
	private:
	char _a;
};

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

7.2 猜猜类的存储

猜测一：类对象中包含类的各个成员。

image-20211017180847132

娜美就有一个问题？

​ 每个对象中成员变量是不同的但是调用一份函数，如果按照当前的方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

猜测二：只保存成员变量，成员函数放在公共代码段。

image-20211017181515388

到此，计算机中对于类对象的存储方式到底是怎么样的？

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1(){}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};

sizeof(A1) : ______ sizeof(A2) : ______ sizeof(A3) : ______

结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

8 隐含的this指针
8.1 引出this指针
class Date
{
public :
void Display ()
{
	cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
void SetDate(int year , int month , int day)
{
	m_year = year;
	m_month = month;
	m_day = day;
}
private :
	int m_year ; // 年
	int m_month ; // 月
	int m_day ; // 日
};
int main()
{
	Date d1, d2;
	d1.SetDate(1999,10,21);
	d2.SetDate(2021,10,9);
	d1.Display();
	d2.Display();
	return 0;
}

对于上述类，有这样的一个问题：
Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

8.2 this指针的特性
  1. this指针的类型：类类型* const
  2. 只能在“成员函数”的内部使用
  3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
9. 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数 image-20211017190336975

10. 构造函数
class Date
{
public:
	void SetDate(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}
void Display()
{
	cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1,d2;
	d1.SetDate(2018,5,1);
	d1.Display();
	Date d2;
	d2.SetDate(2018,7,1);
	d2.Display();
return 0;
}

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

为了完成这一工作，我们需要使用构造函，数构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载 （支持多种方式实例化对象）
class Date
{
public :
// 1.无参构造函数
	Date ()
	{}
// 2.带参构造函数
	Date (int year, int month , int day )
	{
		m_year = year ;
		m_month = month ;
		m_day = day ;
	}
private :
	int m_year ;
	int m_month ;
	int m_day ;
};
void TestDate()
{
	Date d1; // 调用无参构造函数
	Date d2 (2021, 10, 9); // 调用带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();
}
  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
class Date
{
public:
/*
// 如果用户显式定义了构造函数，编译器将不再生成
Date (int year, int month, int day)
{
	m_year = year;
	m_month = month;
	m_day = day;
}
*/
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
}

我们不写构造函数，编译器会默认生成构造函数，但他会做出一些不可思议的处理：

  1. 成员类型分为

    • 内置成员类型
    • 自定义类型

  2. 对于内置成员类型编译器不会初始化

    对于自定义类型编译器会调用它的构造函数进行初始化

  1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
// 默认构造函数
class Date
{
public:
Date()
{
	m_year = 1900 ;
	m_month = 1 ;
	m_day = 1;
}
Date (int year = 1900, int month = 1, int day = 1)
{
	m_year = year;
	m_month = month;
	m_day = day;
}
private :
	int m_year ;
	int m_month ;
	int m_day ;
};
// 以下测试函数能通过编译吗？
void Test()
{
	Date d1;
}

对于系统生成的默认构造函数，只要不传参就可以调用。

但是有一种情况：

Date()
{
	m_year = 0;
	m_month = 1;
	m_day = 1;
}

Date(int year = 1, int month = 1， int day = 1)
{
	m_year = 0;
	m_month = 1;
	m_day = 1;
}

上面的两个构造函数是重载

但是他们俩不能同时存在，原因是有二义性，对编译器有误导，不知道该调用哪一个。

我们一般情况下使用全缺省构造函数，因为他非常好用。

  1. 命名风格

一般都是在成员变量前加前缀或者是加后缀。

// 例如
int m_day;

总结一下：

类似的，这一过程类似于剥洋葱，首先你需要剥掉最外面的那一层皮，然后再层层剥洋葱，这是由内而外进行的。调用构造函数也是先调用内部对象是自定义类型的构造函数，然后再调用自己的。

11. 析构函数

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

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

  2. 无参数无返回值。

  3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

    对于自定义对象的析构函数，如果我们没有定义，编译器找不到，它便什么事情都不做。

  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class SeqList
{
public :
SeqList (int capacity = 10)
{
	m_pData = (DataType*)malloc(capacity * sizeof(DataType));
	assert(m_pData);
	m_size = 0;
	m_capacity = capacity;
}
~SeqList()
{
	if (m_pData)
	{
		free(_pData ); // 释放堆上的空间
		m_pData = NULL; // 将指针置为空
		m_capacity = 0;
		m_size = 0;
	}
}
private :
	int* m_pData ;
	size_t m_size;
	size_t m_capacity;
};
  1. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。
class String
{
public:
String(const char* str = "jack")
{
	_str = (char*)malloc(strlen(str) + 1);
	strcpy(_str, str);
}
~String()
{
	cout << "~String()" << endl;
	free(_str);
}
private:
	char* _str;
};
class Person
{
private:
	String m_name;
	int m_age;
};
int main()
{
	Person p;
	return 0;
}

  1. 关于析构函数的调用顺序：

    对于构造函数初始化后的对象，析构函数去清理的顺序与调用构造函数的顺序相反。

    1. 全局对象先于局部对象进行构造；
    2. 静态对象先于普通对象进行构造。

    构造函数与析构函数互逆。

    同样，调用析构函数的过程类似于古代帝王修陵墓，为了阻止盗墓者，需要从内往外修建帝陵。对于析构函数，调用的时候对于自定义类型的对象会先调用他的析构函数，然后再对这个外部的对象进行清理。

12. 拷贝构造函数

构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
	m_year = year;
	m_month = month;
	m_day = day;
}
Date(const Date& d)
{
	m_year = d.m_year;
	m_month = d.m_month;
	m_day = d.m_day;
}
private:
	int m_year;
	int m_month;
	int m_day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

image-20211017201500746

这就是一个无穷递归。

编译器会强制检查，报错。

  1. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
	m_year = year;
	m_month = month;
	m_day = day;
}
private:
	int m_year;
	int m_month;
	int m_day;
};
int main()
{
	Date d1;
	// 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
	Date d2(d1);
	return 0;
}

对于编译器默认生成的拷贝构造函数，它与拷贝构造和析构有所不同

它并不会区分内置类型和自定义类型，会统一处理：

  • 对于内置类型，按照字节序进行浅拷贝
  • 对于自定义类型，回去调用它的拷贝构造完成拷贝
  1. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
String(const char* str = "jack")
{
	_str = (char*)malloc(strlen(str) + 1);
	strcpy(_str, str);
}
~String()
{
	cout << "~String()" << endl;
	free(_str);
}
private:
	char* _str;
};
int main()
{
	String s1("hello");
	String s2(s1);
}

why???

s1、 s2 指向了同一块空间，并且在s2被析构后，那块空间已经被释放，

但是s1仍然记录这那块空间，这就会造成非法访问。

13 赋值重载运算符
13. 1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字**operator后面接需要重载的运算符符号**。
函数原型：返回值类型 operator操作符(参数列表)
注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@

  • 重载操作符必须有一个类类型或者枚举类型的操作数

  • 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义

  • 跟拷贝构造行为类似，内置类型会完成值拷贝，自定义类型会调用它的赋值重载

  • 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参

  • ​ .* 、:: 、sizeof 、?: 、. 注意以上5个运算 符不能重载。这个经常在笔试选择题中出现。

// 全局的operator==
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }
//private:
    int _year;
    int _month;
    int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year;
    && d1._month == d2._month
    && d1._day == d2._day;
}
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
// bool operator==(Date* this, const Date& d2)
// 这里需要注意的是，左操作数是this指向的调用函数的对象
bool operator==(const Date& d2)
{
    return  _year == d2._year;
		&& _month == d2._month
		&& _day == d2._day;
}
private:
    int _year;
    int _month;
    int _day;
};
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}
13.2 赋值运算符重载
class Date
{
public :
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date (const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    Date& operator=(const Date& d)
    {
        if(this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
	}
private:
    int _year ;
    int _month ;
    int _day ;
};

赋值运算符主要有四点：

  1. 参数类型
  2. 返回值
  3. 检测是否自己给自己赋值
  4. 返回*this
  5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    Date d2(2018，10， 1);
    // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
    d1 = d2；
    return 0;
}

有人会问,我们不是已经有了拷贝构造函数吗?为何还需要赋值重载,直接拷贝不行吗?其实这里有一个误区哦~

拷贝构造使用地方是实例化对象时,而赋值重载适用地方是已经存在两个同类型对象,然后把其中一个对象的值复制给另一个对象

14. const成员
14.1 const修饰的成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

不能显式的去修饰this指针

image-20211022095900951

14.2 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

14.3 小结
  1. 成员函数加const，变成const成员函数是由好处的，这样const对象可以调用，非const对象也可以调用。
  2. 并不是所有的成员函数都要const。要看成员函数的功能，如果成员函数要进行修改性操作，就不能加。对于只读型，就最好加上。
15 再谈构造函数
15.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
	}
private:
    int _year;
    int _month;
    int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

15.2 初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

优点：提高效率

class Date
{
public:
    Date(int year, int month, int day)
        : m_year(year)
        , m_month(month)
        , m_day(day)
	{}
private:
        int m_year;
        int m_month;
        int m_day;
};

注意：

  1. 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）

  2. 类中包含以下成员，必须放在初始化列表中进行初始化：

    1. 引用成员变量
    2. const成员变量
    3. 自定义类型成员（该类没有默认构造函数）
    class A
{
public:
    A(int a)
     : _a(a)
    {}
private:
	int _a;
};
class B
{
public:
    B(int a, int ref)
     : _aobj(a)
     , _ref(ref)
     , _n(10)
{}
private:
    A _aobj; // 没有默认构造函数
    int& _ref; // 引用
    const int _n; // const
};

  3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

    当我们没有显式使用初始化列表时，编译器会使用默认的初始化列表进行初始化。

    class Date
{
public:
	Time(int hour = 0)
		: _hour(hour)
{
	cout << "Time()" << endl;
}
private:
	int _hour;
};
class Date
{
public:
    Date(int day)
    {}
private:
    int _day;
    Time _t;
};
int main()
{
	Date d(1);
}

  4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

    class A
{
public:
    A(int a)
     : _a1(a)
     , _a2(_a1)
{}
void Print() {
    cout<<_a1<<" "<<_a2<<endl;
}
private:
    int _a2;
    int _a1;
}
int main() {
    A aa(1);
    aa.Print();
}	

//A. 输出1 1
//B. 程序崩溃
//C. 编译不通过
//D. 输出1 随机值 √

  5. 初始化列表和函数体内初始可以混合使用，例如要实现一个链表。

    void List()
		: m_head(buyNode(0))
{
    m_head->next = m_head;
    m_head->prev = m_head;
}
15.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

编译器会优化，省去一次拷贝构造的开销。

image-20211022105057035

16. static成员
16.1 static 成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化

//计算程序中共创建了多少个对象？
class A
{
public:
	A() {++_scount;}
	A(const A& t) {++_scount;}
	static int GetACount() { return _scount;}
private:
	static int _scount;
};
int A::_scount = 0;
void TestA()
{
    cout<<A::GetACount()<<endl;
    A a1, a2;
    A a3(a1);
    cout<<A::GetACount()<<endl;
}
16.2 特性
  1. 静态成员为所有类共享，不属于某个具体的实例
  2. 静态成员变量必须在类外定义，定义时不添加static关键字
  3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
  4. 静态成员函数美哟隐藏的this指针，不能访问任何非静态成员，不能使用const去修饰
  5. 静态成员和类的普通成员一样，也有public、protected、private三种访问级别

？？？

  1. 静态成员函数可以调用非静态成员函数吗？

    不可以，由于this指针的存在。

  2. 非静态成员函数可以调用类的静态成员函数吗？

    可以。

17. C++11的成员初始化新玩法

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class B
{
public:
    B(int b = 0)
     :_b(b)
	{}
	int _b;
};
class A
{
public:
    void Print()
    {
        cout << a << endl;
        cout << b._b<< endl;
        cout << p << endl;
    }
private:
	// 非静态成员变量，可以在成员声明时给缺省值。
    // 这里只是声明，不是初始化
    int a = 10;
    B b = 20; 
    int* p = (int*)malloc(4);
    // 静态成员变量不能在这里给缺省值，因为静态成员不在构造函数内初始化
    // 要在类外全局位置进行初始化
    static int n;
};
int A::n = 10;
int main()
{
    A a;
    a.Print();
    return 0;
}

缺省的含义是：

如果在构造函数中我们显式给值了，就不会使用这里的缺省值，没有显式给值就是用这个缺省值，类似于一个备胎。

18. 友元

友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

18.1 友元函数

问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。

class Date
{
public:
    Date(int year, int month, int day)
        : m_year(year)
        , m_month(month)
        , m_day(day)
    {}
ostream& operator<<(ostream& _cout)
{
    _cout<<d._year<<"-"<<d._month<<"-"<<d._day;
    return _cout;
}
prvate:
    int m_year;
    int m_month;
    int m_day
};
int main()
{
    Date d(2017, 12, 24);
    d<<cout;
    return 0;
}

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加**friend关键字**。

class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year, int month, int day)
        : m_year(year)
        , m_month(month)
        , m_day(day)
    {}
private:
        int m_year;
        int m_month;
        int m_day；
};
ostream& operator<<(ostream& _cout, const Date& d)
{
        _cout<<d.m_year<<"-"<<d.m_month<<"-"<<d.m_day;
        return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
        _cin>>d.m_year;
        _cin>>d.m_month;
        _cin>>d.m_day;
        return _cin;
}
int main()
{
        Date d;
        cin>>d;
        cout<<d<<endl;
        return 0;
}

说明：

  • 友元函数可访问类的私有和保护成员，但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用和原理相同
18.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

  • 友元关系是单向的，不具有交换性。
    比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

  • 友元关系不能传递
    如果C是B的友元，B是A的友元，不能说明C时A的友元。

    class Date; // 前置声明
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
    Time(int hour, int minute, int second)
        : m_hour(hour)
        , m_minute(minute)
        , m_second(second)
    {}
private:
    int m_hour;
    int m_minute;
    int m_second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
        : m_year(year)
        , m_month(month)
        , m_day(day)
	{}
    void SetTimeOfDate(int hour, int minute, int second)
    {
    // 直接访问时间类私有的成员变量
        m_t.m_hour = hour;
        m_t.m_minute = minute;
        m_t.m_second = second;
    }
private:
    int m_year;
    int m_month;
    int m_day;
    Time m_t;
};
19. 内部类
19.1 what？

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

19.2 特性
  1. 内部类可以定义在外部类的public、protected、private都是是可以的
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名
  3. sizeof(外部类)=外部类。与内部类没有任何关系。
20. 再次理解封装

C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让整个事情复杂化。

下面举个例子来让大家更好的理解封装性带来的好处，比如：乘火车出行

img

我们来看看火车站：
售票系统：负责售票----用户凭票进入，对号入座

工作人员：售票、咨询、安检、保全、卫生等

火车：带用户到目的地

image-20211022145215003

火车站中所有工作人员配合起来，才能让大家坐车有条不紊的进行，不需要知道火车的构造，票务系统是如何操作的，只要能正常方便的应用即可。

想想下，如果是没有任何管理的开放性站台呢？火车站没有围墙，站内火车管理调度也是随意，乘车也没有规矩，比如：

img

… 1

诸如这样无序所导致的问题引发的诸多不便，更能体现有序的必要性。

缘起云端，逆光而上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值