1.封装
（1）构造函数不是必须在的
可以通过行为修改属性
（2）private和protected区别在于继承那里要学
（3）类默认是私有，struct是共有
私有的好处：控制数据的有效性，意思是在外面给函数的方式写，可以设置多少多少就不能写那种
（4）cube例子不会的点
类内写：
bool equal2(cube& c2)
{
if (h == c2.h && w == c2.w && l == c2.l)return true;
return false;
}
类外写：
cout << cu.equal2(cu2);
（5）点和圆的关系
#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
class point
{
int x, y;//点所在的位置
public:
point(int x, int y)
{
this->x = x; this->y = y;
}
int getx()
{
return x;
}
int gety()
{
return y;
}
};
class circle
{
//int o,r;//分别是圆心所在的位置和半径,不行，得要二维数组
int x, y, r;
public:
circle(int x, int y, int r)
{
this->r = r; this->x = x; this->y = y;
}
/*int geto()//一个坐标一个坐标访问
{
//return o;不需要呀，因为你有构造函数了，可是无法访问呀？
}*/
int getx()
{
return x;
}
int gety()
{
return y;
}
int getr()
{
return r;
}
//把判断变成成员函数，传进来x,y
void relation(point& p)
{
//先求出两点之间的距离,开根号sqrt()
int d = sqrt((p.getx() - x) * (p.getx() - x) + (p.gety() - y) * (p.gety() - y));
if (d < r)cout << "点在圆内" << endl;
else if (d == r)cout << "点在圆上" << endl;
else cout << "点在圆外" << endl;
}
};
int main()
{
circle c(2, 5, 3);
point p(4, 4);
//求点和圆的位置关系
//点在圆内点在圆上点在员外
//只需要将半径和这俩点之间的关系比较即可
c.relation(p);
}全局函数yyds
#include<iostream>
#include<stdio.h>
#include<math.h>
//class point;
using namespace std;
class circle
{
//int o,r;//分别是圆心所在的位置和半径,不行，得要二维数组
int x, y, r;
public:
//class point;
circle(int x,int y, int r)
{
this->r = r; this->x = x; this->y = y;
}
/*int geto()//一个坐标一个坐标访问
{
//return o;不需要呀，因为你有构造函数了，可是无法访问呀？
}*/
int getx()
{
return x;
}
int gety()
{
return y;
}
int getr()
{
return r;
}
//把判断变成成员函数，传进来x,y
/*void relation(point& p)
{
//先求出两点之间的距离,开根号sqrt()
int d = sqrt((p.getx() - x) * (p.getx() - x) + (p.gety() - y) * (p.gety() - y));
if (d < r)cout << "点在圆内" << endl;
else if (d == r)cout << "点在圆上" << endl;
else cout << "点在圆外"<<endl;
}*/
};
class point
{
int x,y;//点所在的位置
public:
point(int x,int y)
{
this->x = x; this->y = y;
}
int getx()
{
return x;
}
int gety()
{
return y;
}
};
//全局函数还是好
void relation(circle c, point p)
{
int d = sqrt((p.getx() - c.getx()) * (p.getx() - c.getx()) + (p.gety() - c.gety()) * (p.gety() - c.gety()));
if (d < c.getr())cout << "点在圆内" << endl;
else if (d == c.getr())cout << "点在圆上" << endl;
else cout << "点在圆外" << endl;
}
int main()
{
circle c(2, 5, 3);
point p(4, 4);
//求点和圆的位置关系
//点在圆内点在圆上点在员外
//只需要将半径和这俩点之间的关系比较即可
relation(c,p);
}咋说呢，你要想用哪个类，你就把这个类写到前面
可以把一个类型为某类的变量定义为另一个类的变量
圆心就是一个点，因此可以将园中的圆心定义为点的类型
（6）我就要把这个类放在不同文件里的知识单独拎出来
把类的声明放在头文件中使用.h文件；类中文件的实现放在cpp中重新起一个cpp文件，这个文件要用声明的头文件；在main函数里面想要使用类，就在前面加上声明的头文件
分别如何书写呢？
例如circle文件：
在头文件里写一个.h文件，然后把类复制进去，去掉函数实现，留下成员变量和成员函数的声明；
然后再源文件里另写一个cpp文件，这个文件写下来类内各个函数的具体实现就好了
这下：函数的声明函数的实现就都分得很清了
2.函数的初始化和销毁
1.构造函数和析构函数都是只要创建了对象，这个函数就会被自动调用，就算你不写，系统会自动给你写一个空的构造函数然后一调用，但是你要是写了就用你的，即便你不调用这个函数，他也会自动调用你写的
2.你要是在函数体内（不是main），那么就会放在栈上，这个函数用完就要析构销毁
main中，只有当main执行完了以后才能执行析构函数
3.匿名构造？三种方法
拷贝构造函数part：
#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
class person
{
public:
int age;
person(int age)
{
this->age = age;
}
//拷贝构造函数
//因为你不能修改你传入的p的属性，因此要用静态引用
person(const person& p)
{
//将传入的人身上的所有属性拷贝到我身上，我现在的age=传入的p的age
age = p.age;
cout << "输出拷贝构造函数" << endl;
}
};
int main()
{
person p1(10);
cout << p1.age << endl;
person p2(p1);
cout << p2.age << endl;//输出也是10
}匿名构造函数
person(10);//没有给这个构造函数一个对象名，就是匿名构造函数
//特点：当前行执行结束，就会被释放，就会析构函数
Person(p3)
//这是不对的
//注意：不要利用拷贝函数初始化匿名对象-编译器会认为Person(p3) == Person p3 编译器会认为是对象的声明
隐式转换法的意思是你写一个person p3=10;系统会自动给你转换成显式法
4.
//值传递的方式给函数参数传值
//※拷贝构造函数为什么可以值传递哪里体现了？都没见拷贝构造函数；
解密时刻：！！！！！！！！！！！！！！！！！！！！！
因为当你值传递的时候就会调用拷贝构造函数，值传递相当于给了一个副本嘛
void dowork(Person p)
{
}
void test02()
{
Person p;
dowork(p);
}
//值方式返回局部对象
//输出那个是引用的解引用吗？，局部对象是p1？拷贝构造函数在哪？好吧，test03第一句就是p=p1;
//现在p有p2的所有属性，因此出来的对象是谁呢？p1本身？也就是想用p来输出p1，那为啥不直接输出dowork2（）呢？
解密：p和p1的不是一个了，地址都不一样，相当于值传递，返回一个p1，就拷贝了一个p1
Person dowork2()
{
Person p1;
cout << (int*)&p1 << endl;
return p1;
}
void test03()
{
Person p = dowork2();
cout << (int*)&p << endl;
}
5.深拷贝和浅拷贝
//再复习一下new的代码
int* p=new int(*p.height)//意思就是为p开辟一个空间，里面的内容是int括号里的内容，左边要是一个指针，指向这段空间如果你的成员变量在堆区，那么就容易出现重复释放空间的问题，因为浅拷贝就相当于别人的值赋给你，同时你的位置也会和他一样，那你俩运行完就都会释放它就释放了两次，所以原因就在于你俩堆的位置在一块呢，所以把他俩放两个位置不就好了，用new开辟一个新空间
Person(const Person& p)
{
cout << "Person的拷贝构造函数调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height;编译器默认实现的就是这行代码
//深拷贝操作
m_Height = new int(*p.m_Height);
}
6.当其他类对象作为本类的类成员时，先构造其他类，然后再构造本类，
析构的顺序与构造相反
3.友元
1.用途：private成员外面不能被访问，但有时候你想让外面某些特殊函数去访问，就采用友元
2.三种：全局函数；成员函数；类；
（1）全局函数：就是给类中前面加上函数的声明，并且给函数声明的前面加上friend
class friend
{
friend void get();
}（2）类：A想用B的，你就给A前面加上B的声明
class A//A里用B了，所以要声明friend
{
friend class B;
private:
B b1;
}
class B
{
}
你放在B里面，就是要给B说别人能访问你（3）成员函数
整明白了
就是你A类里一个函数想访问另一个类B，你就要在B里声明这个函数
不是想全局函数那样直接前面加一个friend，而是要在函数名字前面加上所属的类
例如下面
friend void GoodGay::visit();
