C++类和对象 - 技术栈

感谢大佬的光临各位，希望和大家一起进步，望得到你的三连，互三支持，一起进步

个人主页：LaNzikinh-CSDN博客

文章目录

前言
一.面向对象和面向过程的区别
二.构造函数
三.初始化成员列表
四.对象的析构
总结

前言

前面最开始浅浅的讲解了一下C++的类和对象，现在来详细的讲解类和对象，来了解面对过程编程和面对对象编程的本质区别

一.面向对象和面向过程的区别

什么是过程？过程就是函数。什么是对象，对象具有方法和属性。

面对对象与面对过程的本质区别就是面对过程编程每一个函数就是一个过程执行完就啥也不剩下了，唯一可以输出的就是return但是本质上说也还是过程的一部分，因为一旦执行完return语句本身就不再起作用了，即仅仅走了一个流程而已。所以你会发现面向过程编程想要储存点东西就不得不定义一个全局变量，而函数不过是对全局变量按照流程步骤进行加工处理的过程而已.然而面对对象编程不是这样。面对对象编程，万事万物皆对象，每当建立一个新的对象，就好像建立了一个实体，她有自己的属性和方法（你给她一个东西他会按照自己的方法处理），如果不对其进行销毁那么，她将会一直存在，而不是仅仅走个过程。你可以随时查找她的属性，也可以随时交给她一些东西处理，即对象不仅仅是一个过程模块，不仅仅是走个过场。

例子：求一个立体的体积

面向过程

把问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可，这里我就懒的包装函数了

cpp 复制代码

#include<stdio.h>
#define PI 3.14
int main()
{
    double r, h, C1, Sb, Vb;
    scanf("%lf,%lf", &r, &h);
    C1 = 2 * PI * r;
    Sb = 4 * PI * r * r;
    Vb = PI * r * r * h;
    printf("C1=%.2f\nSb=%.2f\nVb=%.2f\n", C1, Sb, Vb);
    return 0;
}

面向对象

我们先来设置一个类，里面包含了属性和方法，属性就是变量，方法就是函数，注意访问操作符

cpp 复制代码

#include<iostream>
using namespace std;
class Box
{
private:
	int _len;//长
	int _w;//宽
	int _h;//高
	int _s;//面积
	int _v;//体积
public:
	//声明方法
	void set_len(int len);
	void set_w(int w);
	void set_h(int h);
	int get_len();
	int get_w();
	int get_h();
	int get_s();
	int get_v();
};

为什么变量要设置为private？

因为这个属性我输入，之后我就不想再被外界修改了所有一般物体的变量属性都是要设置在这个访问操作符里面的，接下来公用的就是一些函数的声明，我要求一个立体图形的体积，我就直接设置一个立体的内里面装它的长宽高面积和体积，这样不管是什么途径，我都可以拿这个类就是面对对象编程的思路。

函数的完善

cpp 复制代码

//在类的外部实现类中的成员函数，属于内部
void Box::set_len(int len)
{
	//阈值的判断
	if (len <= 0 || len > 100)
	{
		cout << "输入的len错误" << endl;
		return;
	}
	_len = len;
}

void Box::set_w(int w)
{
	if (w <= 0 || w> 100)
	{
		cout << "输入的w错误" << endl;
		return;
	}
	_w = w;
}

void Box::set_h(int h)
{
	if (h <= 0 || h> 100)
	{
		cout << "输入的h错误" << endl;
		return;
	}
	_h = h;
}
int Box::get_len()
{
	return _len;
}
int Box::get_w()
{
	return _w;
}
int Box::get_h()
{
	return _h;
}
int Box::get_s()
{
	return _len* _w;
}
int Box::get_v()
{
	return _len* _w* _h;
}

为什么出了这个呢？我还能用那种的东西去实现这个函数呢？因为在类的外部实现类中的成员函数，属于内部。为什么要加一些判断？阈值的判断，我们以后编程要考虑输入的合理性

主函数

cpp 复制代码

int main()
{
	Box b;
	b.set_len(3);
    b.set_w(4);
	b.set_h(5);
	int a = b.get_s();//12
	int c = b.get_v();//60
	cout << a << endl;
	cout << c << endl;
	return 0;
}

总结：面向对象的编程是将问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象，通过不同对象之间的调用，组合解决问题

二.构造函数

当我们实例化一个对象之后，该如何让他直接有初始值呢？

定义：C++中的类可以定义与类名相同的特殊成员函数构造函数可以有参数也可以，没有参数，没有任何的返回类型

特殊机制：当时实例化了一个对象，后会自动调用 构造函数

cpp 复制代码

class Animal
{
public:
	int age;
public:
	Animal()
	{
		cout << "Animal()" << endl;
		int age = 11;
	}
};
int main()
{
	Animal a;
	cout << a.age << endl;
	
	return 0;
}

例子：下面是什么意思

Animal a;Animal c(); Animal b(4);

cpp 复制代码

//构造函数
class Animal
{
public:
	int age;
public:
	Animal():age(11)
	{
		cout << "Animal()" << endl;
		int age = 11;
	}
	Animal(int b):age(10)
	{
		cout << "Animal():" <<b<<endl;
		int age = 10;
	}
};
int main()
{
	Animal a;//自动调用无参的构造函数
	Animal c(); //不是实例化一个对象，而是声明一个函数返回值是Animal，名字为c
	Animal b(4);//实力化一个对象调用有参的构造函数
	cout <<a.age<< endl;
	cout << b.age << endl;
	return 0;
}

注意：当自己没有实现过构造函数时，系统会自动生产一个无参的构造函数！！！

三.初始化成员列表

其实我们还是没有解决，当我们实例化一个对象之后，该如何让他直接有初始值呢？利用构造函数来进行初始化成员列表

cpp 复制代码

Box(int x, int y, int z) :len(x), w(y), h(z)
{
	cout << "Box(int x, int y, int z" << endl;
}

验证一下

cpp 复制代码

class Animal
{
public:
	int age;
	Animal() :age(11)
	{
		cout << "Animal()" << endl;
	}
};
int main()
{
	Animal a;
	cout << a.age << endl;
	return 0;
}

什么时候必须使用初始化成员列表？

1.成员变量为引用时，2.成员变量被const修饰时3.成员变量是另一个类的实例化对象，且对应的内容没有实现无参构造函数

cpp 复制代码

class C
{
public:
	int x;
	C(int a)
	{
		x = a;
	}
};
class Animal
{
public:
	int age;
	Animal():age(11),p(age),sum(100),n(10)
	{
		cout << "Animal()" << endl;
		/*p = age;
		sum = 100;*/
	}
	Animal(int b):age(10), p(age), sum(100), n(10)
	{
		cout << "Animal():" <<b<<endl;
		/*p = age;
		sum = 100;*/
	}
private:
	int& p;
	const int sum;
	C n;
};

四.对象的析构

如果存在一种情况在构造函数中开辟的空间可是我又没有释放掉，那我不小心调用了构造函数，那不就造成了内存泄露了吗？那该怎么办呢？

cpp 复制代码

#include<iostream>
using namespace std;
//析构函数
class Animal
{
public:
	char* name;
	int age;
	Animal() :age(10)
	{
		cout << "Animal()" << endl;
		name = (char*)malloc(32);
	}
};
int main()
{
	Animal a;
	cout << a.age << endl;
	return 0;
}

这里就要用到我们要讲解的析构函数

如果再过多函数中动态开辟了空间，要在析构函数中释放，对象销毁是自动被调用

cpp 复制代码

#include<iostream>
using namespace std;
//析构函数
class Animal
{
public:
	char* name;
	int age;
	Animal() :age(10)
	{
		cout << "Animal()" << endl;
		name = (char*)malloc(32);
	}
	~Animal()
	{
		cout << "~Animal()" << endl;
		free(name);
	}
};
int main()
{
	Animal a;
	cout << a.age << endl;
	return 0;
}

总结

今天才算是刚刚的进入C++的类和对象，我们讲了C++中面对对象的程序设计方法和面对过程的程序设计方法之间的区别，也讲解了一些C++的机制，构造函数机构函数初始化成列表。我们下次就再讲解在C++中的开辟空间和释放