c++学习（类和对象）

类的封装

#include<iostream>
using namespace std;
/*c++中struct和class 的唯一区别就是默认访问权限不同*/
/*
    具有相同属性和性质的对象可以划分为一个类，一个类有属性（数据变量）和行为（具体实现功能函数）
*/
class circle{
public://    权限：public（一般给具体功能函数设置权限），类内类外都可以访问
            //,private（一般来说是给数据成员设置的权限）,类内可以访问，类外不可以访问
            //protect(主要是用于继承)，类内可以访问，类外不可以访问（如果继承，则子类可以访问protect的内容，不可以访问private的内容）
            //类内，就是定义类的时候，
            //类外，类实例化之后的对象
    float calculatezc(){ //   行为：
        return 2*3.14*r;
    }
    float r;//    属性：
};

struct circle1{
    int a;
    float b;
};

int main()
{
    circle c1;
    circle1 c2;//和类的语法相同，不用再加struct关键字
    c1.r=10;
    cout<<c1.calculatezc()<<endl;

    c2.a=100;
    c2.b=200;

}

对象特性

1.构造函数和析构函数

#include<iostream>
#include<string>
using namespace std;
/*
1.对象的初始化和清理：构造函数和析构函数，
  我们没有定义这两个函数系统自动定义调用，不过这两个函数都是空实现
*/
class persion{
public:
    /*
    构造函数：
    函数没有返回值，也不用void,函数名就是类名，
    可以有参数可以发生函数的重载，且只调用一次
    */
   persion(){};//有参构造和无参构造

   persion(int age,string name){
    this->age=age;
    this->name=name;
   }

   persion(const persion &p){//拷贝构造和普通构造
    age=p.age;
   }
   /*
   析构函数：
   函数没有返回值，不用void，函数名就是类名，还要在之前加~符号，
   不可以有参数，释放时自动调用
   */
  ~persion(){};
private:
    string name;
    int age;
    string number;
    
};

int main()
{
    //1.括号法调用
    persion p1;
    persion p2(10,"fsp");
    persion p3(p2);
    //2.显示法
    //persion p3=persion(p2);

    //3.隐式转换法
    //persion p3=p2;
}

2.深拷贝与浅拷贝

浅拷贝：单纯的文本赋值，默认构造函数就是浅拷贝
深拷贝：在堆区创建新的内存空间，再把数据赋值（主要是类中有指针数据时需要注意）

#include<iostream>
#include<string>
using namespace std;

class persion{
public:
   persion(){};

   persion(int age,int height){
    this->age=age;
    *m_height=height;
   }

   persion(const persion &p){
    age=p.age;
    m_height=new int(*p.m_height);
   }

  ~persion(){
    if (m_height!=NULL)
    {
     delete m_height;
     m_height=NULL;
    }
    
  };
private:
    string name;
    int age;
    string number;
    int* m_height;
    
};

void test(){
    persion p1(10,160);
    persion p2(p1);//如果采用浅拷贝的方式，
                //那么在调用结束时会对m_height所指的内存空间进行重复的释放，从而报错、
                //因此采用深拷贝方式，让p2这个对象中的m_height指向新的内存空间就不会出现上述问题，所以需要对拷贝函数重写
};

int main()
{
    test();

}

3.静态成员

#include<iostream>
#include<string>
using namespace std;

class persion{
public:
/*
  静态成员变量;
  1.静态成员变量在类内申明，类外初始化（出了类定义就是类外）
  2.所有对象共享同一个静态成员变量
  3.静态成员变量也拥有访问权限
*/
    static int age;
    int number;

  /*
  静态成员函数：
  1.所有对象共享同一个静态成员函数
  2.静态成员函数只能调用静态成员变量，不能调用非静态变量
  3.静态成员函数业也有访问权限
  */
  static void fun(){
    m_height=100;
    //number=10;因为静态成员函数是共享的，所以无法区分是哪一个对象调用非静态成员
  }
private:
    static int m_height;
    
};

int persion::age=100;
int persion::m_height=200;
void test(){
   persion p1;
   persion p2;
   /*
    p1.age=p2.age=100;
    p1.m_height p2.m_height这样是无法访问的
   */

  //静态成员变量还可以通过类名访问
  int a=persion::age;
};

int main()
{
    test();

}

4成员函数和成员变量

只有非静态成员变量属于类上，其他的（静态成员变量、成员函数，非静态成员函数）都不属于类上，也即是多个同类型的对象共用同一块代码区。
因此需要使用this指针。
1.解决名称冲突
2.成员函数返回自身时使用return *this;

友元

1.全局函数做友元
2.类做友元
3.成员函数做友元
成为友元后可以访问私有权限的数据

#include<iostream>
#include<string>
using namespace std;

class Buliding {
    friend void visit(Buliding& buliding);//全局函数做友元
    friend void GoodGay::gvisit();//成员函数做友元
    //friend class GoodGay;//类做友元
public:
    Buliding();
public:
    string m_SittingRoom;

private:
    string m_BedRoom;
};
Buliding::Buliding() {//构造函数在类外定义
    m_SittingRoom = "客厅";
    m_BedRoom = "卧室";
};


class GoodGay {
public:
    GoodGay();
    void gvisit();

    Buliding* buliding;

};

GoodGay::GoodGay() {
    buliding = new Buliding;

}
void GoodGay::gvisit() {
    cout << buliding->m_SittingRoom << endl;
    cout << buliding->m_BedRoom << endl;
}



void visit(Buliding& buliding) {//全局函数
    cout << buliding.m_SittingRoom << endl;
    cout << buliding.m_BedRoom << endl;
}

int main()
{
    Buliding bulid;
    visit(bulid);
	GoodGay gg;
	gg.gvisit();
}