C++的类和对象（一）

目录

<一>类的引入

<二>类的定义

类有两种定义方式：

<三>类的访问限定符及封装

<四>类的作用域

<五>类的实例化

<五>类类型大小的计算

<六>this指针(灰常重要)

1，this指针的引出

2，this指针特性

3,this指针存在哪里?

4，关于this指针为nullptr的问题。

---

<一>类的引入

在C语言中结构只能定义变量，在c++中结构不仅可以定义变量，也可以定义函数。比如：之前在学数据结构的时候，我们用C语言来实现栈（stack），结构中只能定义变量，现以c++的方式实现会发现struct（结构体关键字）中还可以定义变量。

struct的功能被放大了。

#include
using namespace std;
 
typedef int DateType;
struct stack
{
	//在c++中升级了struct的功能，struct兼容了C语言的所有用法，而且还把他升级成了类（既有成员函数，也有成员变量）。
	 
	//结构中可以定义函数
	void Init(int capacity)
	{
		DateType* tmp = (DateType*)malloc(sizeof(DateType) * capacity);
		if (tmp == NULL)
		{
			perror("malloc");
			return ;
		}
		_array = tmp;
		_capacity = capacity;
		_size = 0;
	}
 
	void push(const DateType& date)//注意这里使用的const。可能在调用的时候使用的是a.push(10);//10是一个常数。必须用const引用接收。
	{
		//这里写的简单就不写扩容这也个功能了
		_array[_size] = date;
		_size++;
	}
 
	DateType top()
	{
		return _array[_size - 1];
	}
 
	void Destory()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	void print()
	{
		for (int i = 0; i < _size; i++)
		{
			cout << _array[i] << "";
		}
		printf("\n");
	}
 
 
	//结构中可以定义变量
	DateType* _array;
	int _size;
	int _capacity;
 
};
 
int main()
{
	stack a;
	a.Init(10);
	a.push(1);
	a.push(2);
	a.push(3);
	a.push(4);
	a.print();
	cout << a.top() << endl;
 
	a.Destory();
	return 0;
}

上面的结构定义，在c++中一般使用class来定义。

<二>类的定义

就是用class来代替结构的struct

class classname
{
    //成员函数（类的方法）
 
    //成员变量（类的属性）
 
};//注意后面还有一个分号。
//class为定义类的关键字，ClassName为类的名字，
//{}中为类的主体，注意类定义结束时后面分号不能省略。
 

类有两种定义方式：

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

//这种就是声明和定义放在一起
class name
{
public://公有的
	void Add()//编译器可能会将其视为内联函数。
	{
 
	}
 
private://私有的
	int _size;
	char _ch;
	char* _pc;
};

2.声明和定义分开存放。就是声明放在（.h）中而定义放在cpp中。注意这里需要加类域和域作用限定符。

//test.h文件
class classname
{
public://公有的
 
	void Add();//这里只是函数的声明。
 
 
private://私有的
	int _size;
	char _ch;
	char* _pc;
};

//test.cpp文件
void classname::Add()
{
 
}

一般情况下，在项目中更希望采用第二种方式。注意为了练习方便也会采用第一种方式。

注意：在类成员变量定义的时候一般会在变量名前面加一个下划线，或者后面加一个下划线，或者加一个标记符。

class data
{
public:
	void Init(int year, int month, int day)//这里就会出问题到底那个是成员变量，那个是函数的参数。
	{
		year = year;
		month = month;
		day = day;
	}
 
private:
	int year;
	int month;
	int day;
};

一般会标记一下，代码的1可读性变高，避免了一下歧义。

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

也可以采用其他的方式标记，这都无所谓的。

<三>类的访问限定符及封装

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

 

访问限定符的说明：

• 在类里面，不受访问限定符的限制，可以随便使用。在定义成员函数的时候也是可以随便访问的。
• public修饰的成员函数在类外面可以直接被访问。
• protected和private 在类外面是不能直接被访问的，（此处的protected和private是类似的）
• 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
• 如果后面没有访问限定符，作用域就到 } 即类结束。
• class的默认访问权限为private，struct为public(因为struct要兼容C，这也就是我们刚刚写的struct类为啥可以直接在外面使用)
• 访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

<四>类的作用域

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

class classname
{
public:
	int Add();
 
private:
	int a;
	int b;
};
//只有在外部定义的时候，才能这样做。
//这里需要指定Add属于classname这个类域
int classname::Add()
{
	cout << a << b << endl;
	return a + b;
}

<五>类的实例化

类定义完成后是一个类类型，和结构是一样的原理，只是定义了一个类型，并没有去开辟空间。

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

注意：

• 1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没 有分配实际的内存空间来存储它；
• 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。
• 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设 计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象 才能实际存储数据，占用物理空间

下面就是错误用例：

 

<五>类类型大小的计算

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

结构体内存对齐规则：

• 第一个成员在与结构体偏移量为0的地址处。
• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的对齐数为8。也可以通过：#pragma pack(4) 修改默认对齐数为4。
•  结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

拓展：

这里有些人就会想了，那成员函数存在哪里呢，这里我们来解释一下，成员函数纯在公共代码区，（代码段）（常量区）。会有一个类成员函数表，存放成员函数的地址。调用的时候就会去成员函数表里面找对应的函数地址，然后调用这个函数。所以实例化的对象只是存储成员变量的。成员函数并没有存放在对象里面。而是1存放在一个公共的区域。

举例：
 

class a1//空类
{
private:
public:
};
 
class a2
{
public:
private:
	int a;
	int b;
	int c;
};
int main()
{
	cout << sizeof(a1) << endl; //1
	cout << sizeof(a2) << endl; //12
	return 0;
}

<六>this指针(灰常重要)

1，this指针的引出

class Data
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
	void print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	Data a, b;
	a.Init(2001, 12, 23);
	b.Init(2011, 12, 23);
	a.print();
	b.print();
 
	return 0;
}

对于上述类，

• 有这样的一个问题： Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函 数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
• C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏 的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编 译器自动完成。

2，this指针特性

• this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
• 只能在“成员函数”的内部使用
• this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。
• this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传 递，不需要用户传递

	void Init(int year, int month, int day)
	{
		cout << this << endl;//这里可以尝试打印一下 观察观察。
		_year = year;
		_month = month;
		_day = day;
	}
 
//实际上函数的原型是这样的，this指针被隐藏了，不用自己传参，也不需要自己调用
	void Init(Data* const this, int year, int month, int day)
	{
		cout << this << endl;
 
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

3,this指针存在哪里?

他是函数的一个参数，一般存在于栈帧当中，调用类成员函数的时候才会被创建。有些编译器优化了这个地方，将他存在ecx（寄存器）当中。例如VS。

4，关于this指针为nullptr的问题。

//这里会正常编译通过。
//因为没有对虽然this指针是nullptr，但是函数中并没有对this指针进行解引用操作。
class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
 
 
int main()
{
	A* p = nullptr;//这里没有实例化对象出来，并没有给内存空间。
	
	p->Print();//调用print()函数。
 
	return 0;
}

 
//这个会运行崩溃
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;//这里this指针为空，涉及到空指针解引用的问题。会报错。
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
 
	return 0;
}