从零开始学习C++第五篇：类和对象

一、类及其实例化

定义类

1.声明类

class 类名{

private：

        私有数据和函数；

public：

        私有数据和函数；

protected：

        保护数据和函数；

}

2.定义成员函数

返回类型 类名::成员函数名（参数列表）{

        成员函数的函数体；//内部实现

}

::是作用域运算符，用于表明其后的成员函数是属于这个特定的类

3.成员函数的赋值

不能在类体内或外给数据成员赋值，应当构造对象后，用“.”运算符调用设置数据的成员函数赋初值。

4.定义类对象指针

类名*  对象指针名；    对象指针名=对象的地址；

也可以直接初始化： 类名* 对象指针名=对象的地址；

类对象的指针可以通过“->”运算符访问对象的成员，即：

对象指针名 -> 对象成员名

#include <iostream>
using namespace std;

class Point{
private:
	int x,y;  //私有属性

public:
	void setxy(int a,int b){  //设置x y的值
		x=a,y=b;
	}
	void move(int a,int b){ //x y加上固定的值
		x=x+a,y=y+b;
	}
	void display(){           //输出x y
		cout<<"x="<<x<<"  y="<<y<<endl;
	}
	int getx(){
		return x;
	}
	int gety(){
		return y;
	}

};

/*在类的外面定义print函数  使用Point类的指针和引用作为参数，形成重载函数*/
void print(Point* a){
	a->display();
}
void print(Point& a){
	a.display();
}

int main() {
	Point A,B,*p;

	Point &RA=A;//声明RA引用A
	A.setxy(30, 20);
	RA.move(200, 20);
	print(RA);

	B=A;
	p=&B;
	B.move(32, 64);
	p->setxy(300, 80);
	print(p);

	return 0;
}

运行结果：

x=230  y=40
x=300  y=80

二、构造函数

如果个人没有定义构造函数，编译器会定义一个默认构造函数：

Point :: Point（）{ }

类的构造函数可以在类体内，也可以在类体外定义。

构造函数名称和类名相同，且不许指定返回值。

#include <iostream>
using namespace std;
class Point{
private:
	int x,y;
public:
	Point();//在内部定义不带参的构造函数
	Point(int a,int b);//带参

};

//Point::Point(){
//	x=0,y=0;
//	cout<<"Initializing default"<<endl;
//}
Point::Point():x(0),y(0){    //与上式表达意思相同
	cout<<"Initializing default  "<<"x="<<x<<" y="<<y<<endl;
}
Point::Point(int a,int b):x(a),y(b){    //与上式表达意思相同
	cout<<"x="<<x<<" y="<<y<<endl;
}


int main() {
	Point b;
	Point a(20,30);
	Point c[2];//程序为对象数组c[2]分配内存，然后调用不带参数的构造器来初始化，为每一组数组元素调用一次构造函数。
	Point d[2]={Point(5,7),Point(8,12)};//调用带参数的构造器来初始化，为每一组数组元素调用一次构造函数。先将d[0]的数据成员x y分配为5、7
	return 0;
}

运行结果：

Initializing default  x=0 y=0
x=20 y=30
Initializing default  x=0 y=0
Initializing default  x=0 y=0
x=5 y=7
x=8 y=12

构造函数和new关键字

#include <iostream>
using namespace std;
class Point{
private:
	int x,y;
public:
	Point();//在内部定义不带参的构造函数
	Point(int a,int b);//带参

};

//Point::Point(){
//	x=0,y=0;
//	cout<<"Initializing default"<<endl;
//}
Point::Point():x(0),y(0){    //与上式表达意思相同
	cout<<"Initializing default  "<<"x="<<x<<" y="<<y<<endl;
}
Point::Point(int a,int b):x(a),y(b){    //与上式表达意思相同
	cout<<"x="<<x<<" y="<<y<<endl;
}


int main() {
//	Point b;
//	Point a(20,30);
//	Point c[2];//程序为对象数组c[2]分配内存，然后调用不带参数的构造器来初始化，为每一组数组元素调用一次构造函数。
//	Point d[2]={Point(5,7),Point(8,12)};//调用带参数的构造器来初始化，为每一组数组元素调用一次构造函数。先将d[0]的数据成员x y分配为5//、7

	//Point *pt1=new Point;
	Point *pt1=new Point();//与上式相同
	Point *pt2=new Point(2,3);
	delete pt1;
	delete pt2;
	return 0;
}

运行结果：

Initializing default  x=0 y=0
x=2 y=3

构造函数的默认参数

如果想定义有参构造函数，又想使用无参形式的构造函数。

include <iostream>
using namespace std;
class Point{
private:
	int x,y;
public:
	Point(int=0,int=0);
};

Point::Point(int a,int b):x(a),y(b){
	cout<<"x="<<x<<" y="<<y<<endl;
}
int main() {
	Point a;
	Point *b=new Point(2,5);
	Point c[2];
	Point d[2]{Point(2,5),Point(8,7)};
	return 0;
}

运行结果：

x=0 y=0
x=2 y=5
x=0 y=0
x=0 y=0
x=2 y=5
x=8 y=7

复制构造函数

引用在类中一个很重要的用途就是复制构造函数，对于类A而言，复制构造函数的原型如下：A::A(const A &)

三、析构函数

在对象消失时，使用析构函数释放由构造函数分配的内存。析构函数类名相同，为了与构造函数区分，在前面加上“~”，析构函数无参数，无返回值。

类的对象数组的每个元素调用一次析构函数，全局对象数组的析构函数在程序结束之前调用一次。

当使用delete删除一个对象时，先调用析构函数，然后释放内存。与new建立对象相反。

在定义类的时候，没有定义析构函数，也会默认建一个。

四、TIPS

成员函数重载及其默认参数

this指针

使用this指针，保证每个对象都可以有自己的数据成员。

this指针时C++实现封装的机制，它将对象和该对象调用的成员函数连接在一起。

更多this指针资料：https://www.cnblogs.com/liushui-sky/p/5802981.html

/*设计一个点Point类，再设计一个矩形类，矩形类用Point类的点做对角顶点，输出四点坐标和面积*/
#include <iostream>
#include <math.h>
using namespace std;
class Point{
private:
	int x,y;
public:

	int getX() {
		return x;
	}

	void setX(int a) {
		x = a;
	}

	int getY() {
		return y;
	}

	void setY(int a) {
		y = a;
	}


};



class juxing{
private:
	int a,b,c,d;
	Point A();
	Point B();
	Point C();
	Point D();
public:
	void shuru(Point A,Point B,Point C,Point D){
		cout<<"输入对角线坐标"<<endl;
		cin>>a>>b>>c>>d;
//		A.setX(a);
//		A.setY(b);
//		B.setX(a);
//		B.setY(d);
//		C.setX(c);
//		C.setY(d);
//		D.setX(c);
//		D.setY(b);           在这里赋值  没有用...
	}
	void putzm(Point A,Point B,Point C,Point D){
		A.setX(a);
		A.setY(b);
		B.setX(a);
		B.setY(d);
		C.setX(c);
		C.setY(d);
		D.setX(c);
		D.setY(b);
		cout<<"A点坐标为（"<<A.getX()<<","<<A.getY()<<")"<<endl
				<<"B点坐标为（"<<B.getX()<<","<<B.getY()<<")"<<endl
				<<"C点坐标为（"<<C.getX()<<","<<C.getY()<<")"<<endl
				<<"D点坐标为（"<<D.getX()<<","<<D.getY()<<")"<<endl;

		int mianji=(sqrt((b-d)*(b-d)))*(sqrt((a-c)*(a-c)));
		cout<<"面积为"<<mianji<<endl;

	}
};
int main() {
	juxing A1;
	Point A,B,C,D;
	A1.shuru(A, B, C, D);
	A1.putzm(A, B, C, D);
	return 0;
}

运行结果：

输入对角线坐标
23
62
39
54
A点坐标为（23,62)
B点坐标为（23,54)
C点坐标为（39,54)
D点坐标为（39,62)
面积为128