类和对象 1 (类和对象引入, 限定符及封装, 类大小的计算, this指针)

1. C++定义类的方式 & 封装:

	(1). struct + 类名 + { } + ;  (默认访问权限是public)
	(2). class + 类名 + {} + ;    (默认访问权限是private)

类中可以定义成员变量和成员函数

C++的封装的语法体现: 类, 访问限定符

访问限定符 : public, protected, private
作用范围: 从当前限定符到下一个限定符
只限制成员在类外的访问权限, 类内部不受限制

要说明的是protected在这里不多做解释, 现在protected和private没什么区别, 在后面继承的时候会有区别

下面给出代码以便理解

struct Student {
	void display() {
	
	}
	
	void setId(int id) {
		_id = id;
	}
	
	void setNumber(int num) {
		_number = num;
	}


	int _number;
	int _id;
	char name[10];
	char gender[10];
	char major[10];
};


class Student2 {
//公有成员, 在类外可见
public:
	//成员函数
	void display() {
	
	}
	
	void setId(int id) {
		_id = id;
	}
	
	void setNumber(int num) {
		_number = num;
	}
	
//私有成员, 在类外不可见
private:
	//成员变量
	int _number;
	int _id;
//保护成员, 在类外不可见
protected:
	char name[10];
	char gender[10];
	char major[10];
};

在类内声明类外定义要加上类域

class A {
	void fun();
};

void A::fun() {
	cout << "fun()" << endl;
}

2. 类和对象

对象是一个变量, 是类的实例化

//我们定义的类不占内存, 相当于设计图纸
//创建的类变量才占空间
void test2() {
	//类的实例化: 创建一个类类型的变量的过程
	//变量: 对象--> 自定义类型的变量一般称为对象
	A a;
}

3. 类大小的计算

对象模型中只存放普通的成员变量, 不存放成员函数, 成员函数放在公共的代码段
空类的大小为1 (这一个字节可以理解成标记字节, 描述这个类是存在的)

class C {
	int _c;
};

class D {
	int _c;
	void fun1() {
		int a = 1;
		float b = 2.0;
		char c = 'c';
	}
};

class E {
	void fun1() {
		int a = 1;
		float b = 2.0;
		char c = 'c';
	}
};

class F {	

};

void test3() {
	cout << sizeof(C) << endl;
	cout << sizeof(D) << endl;
	cout << sizeof(E) << endl;
	cout << sizeof(F) << endl;
}

运行结果如下

类的大小也遵循内存对齐的规则

首先得掌握结构体的对齐规则：
1. 第一个成员在与结构体变量偏移量为0的地址处。 
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
		对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8
Linux中的默认值为4 
3.  结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。 
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是 所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

插播一个在vs中能改默认对齐数的语句

#pragma pack(8)

下面给个计算类大小的栗子瞅瞅

class G {
	char _c; //1
	double _d; //16
	int _a; //20
	char _c2; //21
	//24
	
	//嵌套
	class H {
		double _d; //8
		char _c;  //9
		int _a;   //16
		char _f;  //17
	};
	H _h;//这里创建成员对象才算H的大小, 否则不算H, G的大小还是24
};

计算偏移量

同样给个栗子

struct I {
	char _c; //1
	double _d; //16
	int _a; //20
	char _c2; //21
};


void test4() {
	I i;
	//计算偏移量
	cout << (char*)&i._c2 - (char*)&i << endl;
}

这样就可以算出想要的偏移量

接下来再插播一个知识点

大小端序的判断方法

大端序: 低地址存高位, 高地址存低位 (阅读序, 网络字节序为大端序)
小端序: 低地址存低位, 高地址存高位

判断方法很多, 这里只介绍两种

1. 指针强转
2. 共用体 union

下面给出代码

union U {
	int _a;
	char _c;
};

void test5() {
	//1.指针强转
	int a = 1;
	char* pa = (char*)&a;
	if (*pa == 1)
		cout << "little end" << endl;
	else
		cout << "big end" << endl;

	//2. 共用体
	U u;
	u._a = 1;
	if (u._c == 1)
		cout << "little end" << endl;
	else
		cout << "big end" << endl;
}

4. this指针
大家不妨想想 : 类中的成员函数如果是每个对象都有一个的话…那C++效率最高的脸都被扇飞了…

我们知道成员函数是只有一个的, 那么要怎么调用呢? 这就引出了this指针

this指针始终指向当前对象

1. void Display(Date* const this) 始终指向挡前调用此函数的对象
2. this指针类型: 类类型* const
3. this指针只存在于成员函数中
4. this指针始终作为成员函数的第一个形参
5. 编译器自动传递, 不用显示定义
6. this不是类的成员, 只是一个函数形参, 按理存在栈上, 一般会做优化,存在寄存器中

class Date {
public:
	/*
		void Display(Date* const this) 始终指向挡前调用此函数的对象
		this指针类型: 类类型* const
		this指针只存在于成员函数中
		this指针始终作为成员函数的第一个形参
		编译器自动传递, 不用显示定义
		this不是类的成员, 只是一个函数形参, 按理存在栈上, 一般会做优化,存在寄存器中
	*/
	void Display() { 
		cout << _year << " " << _month << " " << _day << endl;
		cout << this->_year << " " << this->_month << " " << this->_day << endl;
	}

	void SetDate(int y, int m, int d) {
		_year = y;
		_month = m;
		_day = d;
	}

	void fun1() {
		cout << "Date::fun1()" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

那到这里这篇就结束了…要是有遗漏的之后会补上~