【C++学习】类和对象--上（2）

最新推荐文章于 2024-07-20 22:49:13 发布

Code哈哈笑

最新推荐文章于 2024-07-20 22:49:13 发布

阅读量1.9k

点赞数 57

分类专栏：【C++学习】C++ 0基础学习文章标签： c++ 学习开发语言

本文链接：https://blog.csdn.net/2302_79527141/article/details/137267482

版权

【C++学习】C++ 0基础学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细介绍了面向过程与面向对象的区别，类的引入、定义（包括成员变量和访问限定符）、封装、作用域、实例化，以及this指针的概念和应用。通过实例展示了C++中如何利用类和对象进行编程，并探讨了类对象模型和内存对齐规则。

摘要由CSDN通过智能技术生成

一. 面向过程和面向的初步认识

1.面向过程

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

拿做饭举例：
在这里插入图片描述

2. 面向对象

C++是面向对象的，关注的是对象将一件事情拆分成不同的对象，靠对象之间的交互完成。
在这里插入图片描述

上述过程一共有四个对象：人，菜，锅，火
整个主要过程是：人，菜，锅，火四个对象交互完成的，人不需要关注机器人是怎么洗菜，开火的
在这里插入图片描述

二. 类的引入

C语言结构体中只能定义变量

typedef struct Stack
{
	int* a;
	int size;
	int capacity;
}Stack;

int main()
{
	Stack s;
	return 0;
}

在C++中结构体不仅可以定义变量还可以定义函数

struct Stack
{
	void push(int n)
	{
		if (_capacity == _size)
		{
			int* new_a = (int*)realloc(_a, sizeof(int) * _size);
			if (new_a == NULL)
			{
				perror("fail realloc");
				return;
			}
			_a = new_a;
		}
		
		_a[_size] = n;
	}

	int* _a;
	int _size;
	int _capacity;
};

int main()
{
	Stack s;//c++中不用typedef也能直接用结构体名
	return 0;
}

上面结构的定义 , C++更喜欢用 class 定义

三.类的定义

class Stack
{
    //类体，由成员函数和成员变量组成
};//  不要忘记冒号

class为定义类的关键字，ClassName为类的名字， {}中为类的主体，注意类定义结束时后面分号不能省略
类体中内容称为类的成员:类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数

1.类的定义–1

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

class test1
{
public:
	//成员函数
	void Function_1()
	{
		//...
	}

	void Function_2()
	{
		//..
	}

private:
	//成员变量
	int n;
};

2.类的定义—2

类的声明放在 .h 文件中，成员函数的定义放在 .cpp 文件中。
注意：成员函数名前需要加类名

.h文件

class test1
{
public:
	//成员函数
	void Function_1();

	void Function_2();

private:
	//成员变量
	int n;
};

.cpp文件

//   类名
void test1::Function_1()
{
	//...
}

//   类名
void test1::Function_2()
{
	//..
}

一般情况下，更期望采用第二种方式。

3.成员变量命名规则建议

不建议的命名方式:

class Date
{
public:
	void Init(int year, int month, int day)
	{
		//这里的year是成员变量还是函数参数？
		year = year;
		//...
	}

private:
	int year;
	int month;
	int day;
};

建议把成员变量稍微做合适的改动：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		//这里的year是成员变量还是函数参数？
		_year = year;
		//...
	}

private:
//比如在变量名前加 _ 
	int _year;
	int _month;
	int _day;
};

四.类的访问限定符及封装

1.访问限定符

C++实现封账的方式:用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用
在这里插入图片描述
【访问限定符说明】

public : 修饰的成员在类外可以直接被访问
protectde 和 private : 饰的成员在类外不能直接被访问(此处protectde 和 private作用类似)
访问限权：作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到 } 即类结束
class默认的访问权限是private,struct默认的访问权限是public(因为c++兼容c)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

【面试题】解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。

2.封装

【面试题】
向对象的三大特性：封装，继承，多态。

类和对象阶段，主要是研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件
在这里插入图片描述

C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用

五 .类的作用域

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

class test1
{
public:
	//成员函数
	void Function_1();

	void Function_2();

private:
	//成员变量
	int n;
};

//这里需要指定 Fubction_1函数属于 test1 这个域类
void test1::Function1_1();

六. 类的实例化

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

1. 类是对对象进行描述的：

是一个模型，一样的东西，限定了类有哪些成员，定义出一个类，并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。

2.一个类可以实例化出多个对象

实例化出的对象占用实际的物理空间，存储类成员变量

//声明出的 Date 类不占空间
class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;
		//...
	}

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


int main()
{
	//实例化出的对象 s 占空间
	Stack s;
	return 0;
}

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

int main()
{
	//实例化出的对象 s 占空间
	//s1 s2 s3 三个对象
	Stack s1;
	Stack s2;
	Stack s2;
	return 0;
}

在这里插入图片描述

七.类对象模型

1.如何计算类对象的大小

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

2.对象的存储方式猜测

对象中包含类的各个成员
缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？
代码只保存一份，在对象中保存存放代码的地址
只保存成员变量，成员函数存放在公共的代码段
问题：对于上述三种存储方式，那计算机到底是按照那种方式来存储的？
我们再通过对下面的不同对象分别获取大小来分析看下

//类中有成员函数和成员变量
class test_1
{
public:
	void Function()
	{

	}

private:
	char c;
	int n;
};

//类中只有有成员函数
class test_2
{
public:
	void Function()
	{

	}

};

//空类
class test_3
{

};

int main()
{
	cout << sizeof(test_1) << endl;//8
	cout << sizeof(test_2) << endl;//1
	cout << sizeof(test_3) << endl;//1
	return 0;
}

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

3.结构体内存对齐规则

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

【面试题】

结构体怎么对齐？为什么要进行内存对齐？
如何让结构体按照指定的对齐参数进行对齐？能否按4 、5任意字节对齐
什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

八. this指针

1.指针的引出

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

	void Print()
	{
		cout << "年：" << _year<<endl;
		cout << "月：" << _month << endl;
		cout << "日：" << _day << endl;
	}

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

int main()
{
	Date d1;
	Date d2;
	d1.Init();
	d2.Init(2025,5,5);
	d1.Print();
	d2.Print();
	return 0;
}

问题：
Date类中有Init和print两个成员函数，函数体中没有关于不同对象的区分，当调用 d1 的 Ini 函数时，该函数是如何知道应该设置d1, 而不是对象d2呢？

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

给大家模拟实现：

class Date
{
public:
	//this指针模拟实现，这样运行是会报错的，
	//编译器不允许我们这么做
	void Init(Date* this,int year = 2024, int month = 4, int day = 2)
	{
		//这三步我们可以自己实现，也可以不做
		//编译器允许我们添加这的 this 指针
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	void Print(Date*this)
	{
		cout << "年：" << this->_year<<endl;
		cout << "月：" << this->_month << endl;
		cout << "日：" << this->_day << endl;
	}

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

int main()
{
	Date d1;
	Date d2;
	d1.Init(&d1);
	d2.Init(&d2,2025,5,5);
	d1.Print(&d1);
	d2.Print(&d2);
	return 0;
}

2. this 指针的特性

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

【面试题】
1.this 指针存在哪？
答：栈区
2 this可以为空吗？
可以
代码实例：
运行结果是什么？
1正常运行 2编译报错 3运行崩溃

class test
{
public:
	void print_1()
	{
		cout << "print()_1" << endl;
	}

	void print_2(int n=1)
	{
		_n = n;
		cout << " print_2" << endl;
	}

private:
	int _n;
};

int main()
{
	test* p = NULL;
	p->print_1();//正常运行
	p->print_2();//运行崩溃

	return 0;
}

这是为什么呢？

class test
{
public:
	//这里的this=NULL,但是该函数没有解引用
	void print_1(test* this)
	{
		cout << "print()_1" << endl;
	}

	//这里的this=NULL,该函数解引用了，
	//所以会崩溃
	void print_2(test* this, int n = 1)
	{
		this->_n = n;
		cout << " print_2" << endl;
	}

private:
	int _n;
};

int main()
{
	test* p = NULL;
	//这里的两个p只是为了传递p的指针变量，并没有解引用
	p->print_1();
	p->print_2();

	return 0;
}

这样呢？

int main()
{
	test* p = NULL;
	(*p).print_1();
	(*p).print_2();
	return 0;
}

这里的两个p只是为了传递p的指针变量，并没有解引用。和上面结果一样。

Code哈哈笑

关注

57
点赞
踩
43

收藏

觉得还不错? 一键收藏
4
评论
【C++学习】类和对象--上（2）

/类体，由成员函数和成员变量组成// 不要忘记冒号class为定义类的关键字，ClassName为类的名字， {}中为类的主体，注意类定义结束时后面分号不能省略类体中内容称为类的成员:类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数声明和定义全部放在类体中，需注意:成员函数如果在类中定义，编译器可能会将其当成内联函数。public://成员函数//...//..private://成员变量int n;
复制链接

扫一扫