C++————类与对象＜一＞

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

比如以上代码，由于需要访问private中的成员，所以需要用到::作用域解析符指明成员属于哪个类域。

六、类的实例化

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

1. 类只是 一个 模型 一样的东西，限定了类有哪些成员，定义出一个类 并没有分配实际的内存空间 来存储它。

2. 一个类可以实例化出多个对象， 实例化出的对象 占用实际的物理空间，存储类成员变量

3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

 
class Date
{
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()
{
    //将Date类实例化出多个对象
	Date d1;
	Date d2;
	Date d3;
	Date d4;
    return 0;
}

七、类对象大小及存储方式

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

结果如下：

 通过上面的例子与运行结果我们可以发现，无论有没有成员函数，并不会影响类的大小，主要影响类的大小的是成员变量，并且空类占1字节的空间，虽然空类中没有内容，但也有相应的地址。

总结：计算类或者类对象的大小，只看成员变量，考虑内存对其，c++的内存对其规则与c语言一致。

1. 第一个成员在与结构体偏移量为 0 的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

 八、隐藏的this指针

我们首先定义一个日期类：

#include
using namespace std;
 
class Date
{
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()
{
	Date d1;
	d1.Init(2022, 1, 15);
	d1.Print();
 
	Date d2;
	d2.Init(2022, 1, 16);
	d2.Print();
	return 0;
}

 对于上述类，有这样一个问题：

Date类中有Init和Pint两个成员函数，函数体中没有关于不同对象的区分，那当s1调用Init函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？

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

#include
using namespace std;
 
class Date
{
public:
	//void Init(Date* this,int year, int month, int day)
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
 
 
		/*this->_year = year;
		this->_month = month;
		this->_day = day;*/
	}
	//void Print(Date* this)
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2022, 1, 15);//d1.Init(&d1,2022, 1, 15);
	d1.Print();//d1.Print(&d1);
 
	Date d2;
	d2.Init(2022, 1, 16);//d2.Init(&d2,2022, 1, 15);
	d2.Print();//d2.Print(&d2);
	return 0;
}

相关例题

class A
{
public:
 void PrintA()
 {
 cout<<_a<
 }
 
 void Show()
 {
 cout<<"Show()"<
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 p->PrintA();
 p->Show();
}

解析

运行p->Show()时运行成功。

运行p->PrintA()时运行崩溃。

p->Show()：

1、p虽然是空指针，但是p调用成员函数不会编译报错，因为空指针不是语法错误，编译器检查不出来。

2、p虽然是空指针，但是p调用成员函数也不会出现空指针访问，因为成员函数没有存在对象里。

3、这里会把p作为实参传递给隐藏的this指针。（运行崩溃是由于在PrintA成员函数里面this->_a 对空指针进行了解引用）。