类对象的封装001

1、类的初始化 构造析构

1、构造函数：
* 1、没有返回值，不用void
* 2、构造函数名和类型相同
* 3、参数列表可以不同，可以函数重载
* 4、程序在调用对象时会自动调用构造函数
2、析构函数
* 1、没有返回值
* 2、函数名 ： ~ 类名
* 3、不可以重载
* 4、对象销毁前自动调用析构函数

1.2、构造函数：

有参构造、无参构造
普通构造、拷贝构造

class Person{
public:
	int age;
public;
	//默认构造
	Person (){
		cout<<"默认构造"<<endl;
	}
	// 拷贝构造
	Person(const Person &p){
		age=p.age;
	}
	Person(int a){
		cout<<"哈哈啊哈"<<endl;
	}
}

//调用法：
1、括号法
void test001()
{
	Person p(10);
**1 Person p();//这个不行，不会调用默认构造，因为会默认以为是一个函数的声明，一个函数内可以声明另一个函数


2、显示法调用
	Person p3=Person(10);
	Person p4=Person(p3);
	=Person(10);//匿名对象，等号左边是名字，当前行执行完，会回收当前匿名对象
**2 不能用拷贝构造函数来初始化一个匿名对象，因为编译器以为重定义（忽视那个小括号），会报错，


3、隐式转换法
Person p5=20;  // 等价于Person p5=Person(20);
}

1.3拷贝构造函数使用时机

1、用一个对象初始化另外一个对象
2、值传递的方式给函数参数传值
（作为函数的参数）
3、值传递的方式返回局部变量

Person dowork(){
	Person p1;		// 局部变量
	return p1;  // 拷贝出来一个新的对象返回出去
}
void test02(){
	Person p3=dowork();// 拷贝给这个新的对象
}

1.4构造函数的调用规则

声明一个类之后默认会给出3个函数
有参构造
析构函数
拷贝构造

如果自己写了有参构造了，就不会提供无参构造了
如果自己写了拷贝构造函数了，就不提供其他构造函数了

2、深拷贝与浅拷贝

new ->delete
noodle面条
当在堆区用new开辟一个内存时候，析构函数delete释放内存时候就会出现这个，拷贝构造是浅拷贝，只拷贝了内存地址，并没有拷贝那个地址存的值。

解决办法
重写拷贝构造函数，自己开辟内存存变量
在拷贝构造函数时：把这个在堆区存放的变量用这种方式再搞一个新的出来
m_height=new int(* p.m_height);

堆区有开辟内存，就在析构函数释放，深拷贝在堆区，要开辟内存，浅拷贝在栈区，简单的赋值拷贝。

2.2初始化列表

构造函数：

Person(int a,int b,int c):M_A(a),M_B(b),M_C(c){};

3、类对象作为类成员

class A{};
class B{
   A a;
};

先有A，还是先有B?
盲猜先有B XXXXXX
先有胳膊腿！！！
析构相反，栈结构

4、静态成员：

4.1静态成员变量

* 所有对象共享同一份数据
* 在编译阶段分配内存
* 类内声明，类外初始化

class Person{
public:

private:
	static int m_Age;
};
int Person::m_Age=100;

4.2静态成员函数

* 所有对象共享同一个函数
* 静态成员函数只能访问静态成员变量

调用方式：通过对象访问 
Person p;
p.func();
通过类名访问
 Person::func();

5、成员变量和成员函数分开存储

类的空对象占用一个字节，因为为了区分不同的对象
只有非静态成员变量属于类的对象。
静态成员变量属于类，而不属于类的对象。
非静态成员函数也只有一份，不属于类的对象。属于类。
静态成员函数更不属于类的对象。

6、this指针

哪个对象 调用类中的成员函数，this指针就指向该对象。

解决类成员变量和形参重名问题，和返回此对象，返回*this就好了！
练习：链式编程思想

Person& AddPerson(Person & p){  // 返回值类型应该是Person的引用
   this->m_age+=p.m_age;
   return *this;  // 返回this所指向的本体
}

// 可以实现链式编程
p1.AddPerson(q2).AddPerson(p2).AddPerson(p2);
cout<<"p1的年龄是"<<p1.m_age<<endl;

如果返回的是值：Person,而不是引用Person&,就会变成拷贝构造，拷贝出新的Person对象！

6、常函数常对象

常函数：在成员函数后面加一个const就变成常函数了
常函数不允许修改成员变量
常函数中的const 修饰的是this指针,不让this所指向的被修改，
this指针是指针常量，指向固定的地址，地址不能变，但是地址内容可以变

如果还想修改，就在成员属性前加mutable

常对象只能访问常函数
const Person *p;
常对象不能修改成员属性

7、友元函数

1、全局函数做友元函数
2、类做友元
3、成员函数做友元

class Person{
	//友元函数
	friend void showRoom(Person * p);
	public:
	Person(){
		m_sitting="客厅";
		m_bedding="卧室";
}
	
	string m_sitting;
	private:
	string m_bedding;
	
};
void showRoom(Person * p){  // 形参时候 的 *是传地址
	cout<<"客厅"<<p->m_sitting;
	cout<<"卧室"<<p->m_bedding;
	
}
void test001(){

	Person p;
	showRoom(&p);  // 调用的时候 &意思是取地址，
}

7.3类做友元

#include<iostream>
#include<string>
using namespace std;
class Build{
                friend class GoodGay;  // 这里没有括号
        public:
                Build();
        private:
                string m_bedding;
        public:
                string m_counting;

};

class GoodGay{
        public:
                GoodGay();

                void visit();
                Build * building;  // 声明的指一个Build类的指针building
};

Build::Build(){  // 类外实现的构造函数，
        m_bedding="卧室室";
        m_counting="大厅厅";
}
GoodGay::GoodGay(){  // 这个构造函数用new在栈中构造一个对象指针，
        building=new Build();  // new出来的就是指针
}

void GoodGay::visit(){  // 类外实现的一个成员函数，
        //building = new Build;  //这里肯定不行，一般初始化成员变量都是在构造函数中
        cout<<"访问大厅："<<building->m_counting<<endl;
        cout<<"访问卧室："<<building->m_bedding<<endl;

}
void test001(){
        GoodGay gg;
        gg.visit();
}

int main()
{
        test001();
        return 0;
}

7.3类内成员函数做友元

和上一个类做友元一样，只需要把那个

friend class Build;

换成

friend Build::visit();

就可以了。

7、运算符重载

7.1 +

类内成员函数重载

Person& operator+(Person & p)
{

}

类外全局函数重载
Person& operator+(Person & p1,Person &p2){

}