C++知识点——类和对象

一、面向对象三大特性之一——封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
1. C++中struct与class的区别：struct 中默认成员为公有 public ；而 class 中默认成员为私有 private 。在C语言中 struct 中只能声明成员变量，不能声明成员函数函数，但是C++中 struct 可以声明成员函数。
2. 类只是一个像模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。只有当创建类的对象时（实例化），才会为成员变量分配内存空间来存储它。

二、类和对象的大小以及在内存中类的对齐规则

类和对象的大小：对象中只保存成员变量，成员函数存放在公共的代码段。如果一个类中具有虚函数，则对象中还会有一个虚表指针，存放在对象的前四个字节中。静态成员变量也不计入类和对象的大小。综上所述，类和对象的大小就是 成员变量+虚表指针。
需要注意的是，空类的大小为 1 。
我们来看一段代码：
 

class A
{
public:
	A(int _a,double _b)
	{
		a = _a;
		b = _b;
	}
private:
	int a;
	double b;
	static int c;
};
int A::c = 30;
int main()
{
	A obj(10, 20.5);
	cout << sizeof(A) << endl;
	cout << sizeof(obj) << endl;
	return 0;
}

我们可看到，类中有三个成员变量，其中静态成员变量不计入类和对象的大小，也就是说，只有一个 int 型的变量和一个 double 类型的变量，那么大小是多少？是 4+8=12 吗？答案是 16。为什么呢？ 在内存中并不是紧挨着存放的，而是有对齐规则的。
类（结构体）在内存对齐规则：
1. 第一个成员在结构体变量偏移量为0的地址处。
2. 其他成员要对齐到对齐数的整数倍地址处。 对齐数=编译器默认的对齐数与该成员变量大小的较小值。
    vs 下对齐数默认为8 ，Linux 中的对齐数默认为 4 。
3. 结构体总大小为最大对齐数的整数倍。 最大对齐数为所有成员变量的对齐数的最大值。
4. 如果嵌套了结构体，那么嵌套的结构体的对齐数就是自己的最大对齐数的整数倍处。

所以我们来看上面代码，先在内存中存放变量 a 四个字节，变量 b 对齐时需要对齐到偏移量为 8 处，所以类和对象的大小为：4+4+8=16 。

我们再来看另一段代码：
 

class A
{
public:
	A()
	{

	}
private:
	int a;
	char arr[9];
	double b;
};

int main()
{
	A obj;
	cout << sizeof(A) << endl;
	cout << sizeof(obj) << endl;

	return 0;
}}

上面的代码结果又是多少呢? 是 4+(5)+9+(6)+8=32 吗？（括号中数字代表，为了内存对齐而空出来的字节数）
答案是 4+9+(3)+8=24 。这是因为 arr[9] 的对齐数不是 9 而是 1。一个 char 类型的大小。

如果类中有虚函数，则对象中会有一个虚表指针，存放于首地址中 同样遵循内存对齐规则。

我们已经知道结构体在内存中需要对齐，那么为什么需要对齐呢？

1、平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。（提高CPU处理速度）

三、this 指针

C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。
当我们使用对象来调用类中的成员函数时，会将对象的地址传给 this 指针，也就是说 this 指针指向的就是调用成员函数的对象。
我们来看一段代码:

class A
{
public:
	A(int _a,int _b)
	{
		a = _a; 
		b = _b;
	}
	void show()
	{
		cout << a << endl;
		cout << b << endl;
	}
private:
	int a;
	int b;
};

int main()
{
	A obj(10, 20);
	obj.show();
	return 0;
}

执行函数 show 的时候编译器会处理成 show(A* this); this 存放的就是对象 obj 的地址。
也就是说 cout<<a<<endl; 相当于 cout<<this->a<<endl;  这样函数就知道是哪个对象调用了自己。

1. this指针的类型：类类型* const
2. 只能在“成员函数”的内部使用
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参。
5. this 指针存放在 ecx 寄存器中。
6. this 指针可以为空，为空时不能通过 this 指针来调用类中成员变量。

四、类中的默认成员函数

一个空类中并不是什么都没有的，它有六个默认的成员函数：构造函数、析构函数、拷贝构造函数、赋值运算符重载函数、取地址操作符重载、const 取地址操作符重载。
1. 无参构造函数和全缺省构造函数都是默认构造函数，类中只能存在一个默认构造函数，没有构造函数时，会自动生成一个无参构造函数。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 有五个运算符不能被重载    . 点运算符     .* 成员指针访问运算符     :: 域运算符     sizeof 长度运算符   ?: 条件运算符。
4. 以下三种成员变量必须用初始化列表初始化： const 成员变量 ，引用成员变量，类类型成员（该类中没有默认构造函数）
5. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

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 
}

五、 explicit 关键字

在 C++ 中，单参数构造函数（或者是除了第一个参数，其余参数都有默认值的多参构造函数）有两个作用：一是初始化对象，二是隐式类型转换。
 

class A
{
public:
	A(int _a)
	{
		a = _a;
	}
	void print()
	{
		cout << a << endl;
	}
private:
	int a;

};

int main()
{
	A obj(5);
	obj = 10;
	obj.print();

	return 0;
}

上述代码相当于用一个整型 10 给obj 赋值。编译器会用 10 构建一个无名对象，然后用这个无名对象给 obj 赋值。
但是这样的代码不具有可读性，所有引入了 explicit 关键字。用 explicit 修饰构造函数，将会禁止单参构造函数的隐式转换。
 

class A
{
public:
	explicit A(int _a)
	{
		a = _a;
	}
	void print()
	{
		cout << a << endl;
	}
private:
	int a;

};

int main()
{
	A obj(5);
	obj = 10;
	obj.print();

	return 0;
}

这个时候，编译器就会报错：没有与这些操作数匹配的 “=” 运算符。 

六、 static 静态成员。

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

1. 静态成员为所有类对象所共享，不属于某个具体的实例。
2. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
3. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
4. 静态成员和类的普通成员一样，也有public、protected、private 3种访问级别，也可以具有返回值，const修饰符等参数。

七、 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;
}

八、 友元

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声
明，声明时需要加friend关键字。
1. 友元函数可访问类的私有成员，但不是类的成员函数
2. 友元函数不能用const修饰
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4. 一个函数可以是多个类的友元函数
5. 友元函数的调用与普通函数的调用和原理相同

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

class Date; // 前置声明
class Time
{
 friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变
量
public:
 Time(int hour, int minute, int second)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}
 private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
void SetTimeOfDate(int hour, int minute, int second)
 {
 // 直接访问时间类私有的成员变量
 _t._hour = hour;
 _t._minute = minute;
 _t.second = second;
 }
 
private:
 int _year;
 int _month;
 int _day;
 Time _t;
};

在一个类中声明另一类为该类的友元类时，必须要前置声明该友元类。
1. 友元关系是单向的，不具有交换性。
    比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2. 友元关系不能传递
    如果B是A的友元，C是B的友元，则不能说明C时A的友元。

九、 内部类

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

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

class A
{
public:
	A(int _a) :a(_a)
	{
	}
	void print()
	{
		cout << a << endl;
	}
	class B
	{
	public:
		B(int _b) :b(_b)
		{}
		void print(const A& obj)
		{
			cout << obj.a << endl;  // a 为普通成员变量，需要通过类A 的对象来访问
			cout << b << endl;
			cout << aa << endl; // aa 为A类的静态成员变量，可以不通过类A的对象或类名来访问
		}
	private:
		int b;
	};
private:
	int a;
	static int aa;
};
int A::aa = 100;
int main()
{
	A obj1(10);
	A::B obj2(20);
	obj2.print(obj1);
	cout << sizeof(A) << endl;
	cout << sizeof(A::B) << endl;

	return 0;
}

程序运行结果为:

10
20
100
4
4

十、const成员函数

用const修饰的成员函数称为const成员函数。const修饰成员函数实际上是修饰成员函数隐含的this指针，表明在该成员函数中，不能对调用该成员函数的对象做任何修改。

 const对象不可以调用非const成员函数，非const对象可以调用const成员函数；const成员函数内部不可以调用非const成员函数，非const成员函数内部可以调用const成员函数。