c++学习笔记（7）

设计立方体类
求出立方体面积和体积
分别用全局函数和成员函数判断两个立方体是否相等

class cube 
{
private:
	int l;
	int w;
	int h;
public:
	void setl(int ml)
	{
		l = ml;
	}
	int getl()
	{
		return l;
	}
	void setw(int ml)
 	{
  		l = ml;
 	}
 	int getw()
 	{
 		return l;
	}
	void seth(int ml)
	{
  		l = ml;
 	}
 	int geth()
 	{
 		return l;
 	}
 	int calcultes()
 	{
 		return 2*l*w+2*w*h+2*l*h;
 	}
 	int calculatev()
 	{
 		return m*w*h;
 	}
 	//成员函数 只需要一个输入 因为调用时输入了一个数据
 	bool issame1(cube &c)
 	{
 		if(l = c.getl() && w = c.getw() && h = c.geth())
 	} 	
}

cube c1;
c1.setl(10);
c1.setw(10);
c1.seth(10);

s = c1.calculates();
v = c1.calculatev();

cube c2;
c2.setl(10);
c2.setw(10);
c2.seth(10);

//全局函数
bool issame(cube &c1,cube &c2)
{
	if(c1.getl()==c2.getl() && c1.getw()==c2.getw() && c1.geth()==c2.geth() )
	{
		return true;
	}
	return false;
}

ret = issame(c1,c2);
ret = c1.issame1(c2);

点和圆的关系
设计一个圆类，设计一个点类，计算点和圆的关系

class point
{
private:
	int x;
	int y;
}

class circle
{
private;
	int r;
	point center;
	//重点：类也可以嵌套
public:
	void setcenter(point m_center)
	{
		center = m_center;
	}	
}

void iscircle(circle &c,point &p)
{
	int distance = (c.getcenter().getx()-p.getx())*(c.getcenter().getx()-p.getx()) +
	 (c.getcenter().gety()-p.gety())*(c.getcenter().gety()-p.gety())
	 if (distance > c.getr())
	 {
		cout<<"yes"<<edn1;
	 }
}

point p;
circle c;
iscircle(c,p);

类的封装

#include <iostream>
using namespace std;

//只加入声明
//函数的声明以及变量的声明

#include "point.h"
//加入函数的实现，需要加入作用域
void point::sety(int y)
{
	m_y = y;
}

//使用时只需要加入.h头文件

对象的初始化和清理
每个对象都有初始设置以及对象销毁前的清理数据的设置

构造函数和析构函数
对象的初始化和清理是两个非常重要的安全问题

c++利用构造函数和折构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作，对象的初始化和清理工作是编译器强制我们做的事情，因此我们如果不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现

构造函数：主要作用于创建最想时为独享的成员属性赋值，构造函数由编译器自动调用，无需手动调用
析构函数：主要作用于对象销毁前系统自动嗲用，执行一些清理工作

构造函数语法：类名（）{}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法：~类名（）{}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同，在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用而且只会调用一次

class person
{
public:
	//构造函数
	person()
	{
		cout<<"zh"<<end1;
	}
	//析构函数
	~person()
	{
		cout<<"end"<<end1;
	}
}

person p;
//实例化时会自动调用构造函数，只调用一次

void test()
{
	person p;
}
test();
//运行时会自动调用构造和析构，因为局部变量运行完后自动释放，删除前调用了析构函数

构造函数的分类和调用
两种分类方式
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法

class person 
{
	//无参构造或者默认构造
	person()
	{
        	cout<<"gouzao"<<end1;
        }
        //有参构造
        person(int a)
        {
        	cout<<"gouzao"<<end1;
	}
	//拷贝构造函数
	person(const person &p)
	{
	//拷贝输入类的所有属性，加const修饰 确定不会修改原数据
	age = p.age
	}	
}

void test()
{
	//括号法
	person p;
	person p1(10);
	person p3(p1);
	//调用拷贝函数
	//调用默认构造函数时，不要加小括号
	person p();
	//因为会被默认为函数的声明
	//显示法
	person p1;
	person p2 = person(10);
	//调用有参构造
	person p3 = person(p2);
	//调用拷贝构造
	person(10);
	//匿名函数 当前行为执行结束后系统会立即回收匿名对象
	//不要利用拷贝构造函数 初始化匿名对象
	person(p3);
	//默认为对象声明 等于 person p3;
	//隐式转换法
	person p4 = 10;
	//相当于person p4 = person (10);
	person p5 = p4;
}