C++类和对象(1)

目录

1.类的定义

1.1 类定义格式

1.2访问限定符 

1.3类域

2.实例化

2.1实例化概念

2.2对象大小

3.this指针 

---

1.类的定义

1.1 类定义格式

class Stack
{
    //....
};

(1)class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的⽅法或者成员函数。

(2)为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_ 或者 m开头，注意C++中这个并不是强制的，只是⼀些惯例。

(3)C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是 struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。

(4)定义在类⾯的成员函数默认为inline。

        定义一个日期类：

class Date
{
public:
	void Init(int year = 2001, int month = 10, int day = 12) //成员函数
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
    //成员变量,为了区分成员变量，开头加上特殊标识‘_’
	int _year;
	int _month;
	int _day;
}; // 分号不能省略

// C++升级struct升级成了类
// 1、类⾥⾯可以定义函数
// 2、struct名称就可以代表类型

// 不再需要typedef，ListNodeCPP就可以代表类型
//C语言中的定义
typedef struct ListNodeC
{
	struct ListNodeC* next;
	int val;
}LTNode;

//CPP中的定义
struct ListNodeCPP
{
public:
	void Init(int x)
	{
		next = nullptr;
		val = x;
	}
private:
	ListNodeCPP* next;
	int val;
};

1.2访问限定符 

 (1)C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接⼝提供给外部的⽤⼾使⽤。

(2)public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的，以后继承章节才能体现出他们的区别。

(3)访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有访问限定符，作⽤域就到 }即类结束。

(4)class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

(5)⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。

1.3类域

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

(2)类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include<iostream>
using namespace std;

class Stack
{
public:
    //成员函数
    void Init(int n = 4);    //声明
private:
    //成员变量
    int* _array;
    size_t _capacity;
    size_t _top;
};

//声明和定义分离，需要指定类域
void Stack::Init(int n)
{
    _array = (int*)malloc(sizeof(int) * n);
    if (_array == nullptr)
    {
        perror("malloc fail!\n");
        return;
    }

    _capacity = n;
    _top = 0;
}

2.实例化

2.1实例化概念

(1) 类的定义是不会占用物理内存的，⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。

(2)类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。

(3)⼀个类可以实例化出多个对象，实例化出的对象占⽤实际的物理空间，存储类成员变量。

 

#include <iostream>
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和d2，与struct类似
	Date d1;
	Date d2;

	d1.Init(2024, 3, 31);
	d1.Print();

	d2.Init(2024, 7, 5);
	d2.Print();

	return 0;
}

2.2对象大小

        类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包含成员变量，那么成员函数是否包含呢？函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)。所以对象中只存储成员变量，C++规定类实例化的对象也要符合内存对齐的规则。

#include <iostream>
using namespace std;

class A
{
public :
	void Print()
	{
		cout << this << endl;
		cout << "A::Print()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();  //调用成员函数，在汇编层面是通过call调用一个地址，Print()函数指针没有存储在p对象里,没有对空指针解引用
	//p->_a = 1; //这条代码对空指针进行了解引用，所以会报错

	return 0;
}

 

         内存对齐的规则请参考C语言中的自定义类型: 结构体、联合体和枚举中结构体内存对齐这一章节。

#include<iostream>
using namespace std;
 计算⼀下A/B/C实例化的对象是多⼤？
class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch; // 1 8 1
	int _i;   // 4 8 4
};

class B
{
public:
	void Print()
	{
		//...
	}
};
class C
{};

class D
{
private:
	char i;
};

int main()
{
	//没有成员变量时默认为1,纯粹是为了占位标志对象存在
	A a;
	B b;
	C c;
	D d;
	cout << sizeof(a) << endl;
	cout << sizeof(b) << endl;
	cout << sizeof(c) << endl;
	cout << sizeof(d) << endl;

	return 0;
}

3.this指针 

#include <iostream>
using namespace std;

class Date
{
public:
	// void Init(Date* const this, int year, int month, int day)  实参和形参不写this
    //this指针(形参)一般在栈中
	void Init(int year, int month, int day)
	{
		// 编译报错：error C2106: “=”: 左操作数必须为左值
		// this = nullptr;

		_year = year;
		this->_month = month;
		this->_day = day;  //成员函数中可以显式的写this
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这⾥只是声明，没有开空间
	int _year;
	int _month;
	int _day;
};

int main()
{
	// Date类实例化出对象d1和d2
	Date d1;
	Date d2;
	// d1.Init(&d1, 2024, 3, 31); 隐式的传指向对象的指针
	d1.Init(2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);
	d2.Print();
	return 0;
}

(1) Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了 ⼀个隐含的this指针解决这⾥的问题。

(2)编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this指针。⽐如Date类的Init的真实原型为， void Init(Date* const this, int year,int month, int day)。

(3)类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year;

(4)C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显⽰使⽤this指针。