C++基础 | 类和对象

类

class Circle
{
private:
        double radius ; //成员变量 
public : //类的访问控制
         void Set_Radius( double r )
         {
            radius = r;
         }               //成员函数
          double Get_Radius()
          {
              return radius;
          }.     //通过成员函数设置成员变量 
          double Get_Girth()
          {
                return 2 * 3.14f * radius;
           }     //通过成员函数获取成员变量 
           double Get_Area()
           {
                return  3.14f * radius * radius;
            }
};

也可以这样：

class Date
{ 
public:
    void init(Date &d);
    void print(Date & d);
    bool isLeapYear(Date & d);
private:
    int year;
    int month;
    int day; };
    void Date::init(Date &d)
    {
        cout<<"year,month,day:"<<endl;
        cin>>d.year>>d.month>>d.day;
    }
    void Date::print(Date & d)
    {
        cout<<"year month day"<<endl;
        cout<<d.year<<":"<<d.month<<":"<<d.day<<endl;
    }
    bool Date::isLeapYear(Date & d)
    {
        if((d.year%4==0 && d.year%100 != 0) || d.year%400 == 0)
            return true;
        else
            return false;
}

封装

封装有2层含义(把属性和方法进行封装对属性和方法进行访问控制)
Public修饰成员变量和成员函数可以在类的内部和类的外部被访问。
Private修饰成员变量和成员函数只能在类的内部被访问。
Protected保护控制权限，在类的继承中跟private有区别，在单个类中和private是一样的。

构造与析构

class Test {
  public: 
    Test() {     // 无参数构造函数
          ; 
    }
      Test(int a, int b) {    //带参数的构造函数 
      ;
   }

Test(const Test &obj) {  //拷贝构造函数 
    ;
   }
~Test(){.  //析构函数
;
}
    private:
        int a;
        int b;
 };

构造函数和析构函数都不能有返回值，且析构函数不能有参数。
析构函数的作用,并不是删除对象,而在对象销毁前完成的一些清理工作。
即：

构造规则：
1 在对象创建时自动调用,完成初始化相关工作。
2 无返回值,与类名同,默认无参,可以重载,可默认参数。
3 一经实现,默认不复存在。

析构规则:
1 对象销毁时,自动调用。完成销毁的善后工作。
2 无返值 ,与类名同。无参。不可以重载与默认参数
3.析构函数调用顺序，谁先构造的，谁就后析构

若没写构造函数和析构函数，编译器会提供默认的构造函数和析构函数，通常函数里面什么都没有

拷贝构造函数

class Test {
  public:
    Test()  {
        cout<<"我是无参构造函数，被调 了"<<endl;
     }
     Test(int a)  {
        m_a = a; 
      }
  Test(const Test &another_obj) //拷贝构造函数 {
            cout<<"我也是构造函数，我是通过另外一个对象, 来初始化我  "<<endl;
            m_a = another_obj.m_a;
        }
    ~Test() {
  cout<<"我是析构函数， 动被调 了"<<endl; 
    }
        void printT()
        {
            cout << "m_a = " << m_a <<endl;
        }
  void operator=(const Test &another_obj){  //重载操作符
   m_a = another_obj.m_a;
 }

    private:
        int m_a;
};


int main(){
  Test  t1(3);   //构造函数是初始化时调用
  Test  t2(t1);   //调用了拷贝构造函数
  Test  t3=t1;   //调用了拷贝构造函数
  Test  t4;      //没有调用了拷贝构造函数，因为是无参，调用的是无参构造函数
    t4=t1;        //重载操作符，可以达到拷贝构造函数的效果，但无调用拷贝构造函数
}
//这里是t1最后析构

有关拷贝构造的应用场景和匿名对象

#include <iostream>
using namespace std;
class Location
{
//带参数的构造函数
public:
Location( int xx = 0 , int yy = 0 ) {
            X = xx ;
            Y = yy ;
            cout << "Constructor Object." <<endl;
}
Location(const Location & obj) //copy构造函数 
{
            X = obj.X;
            Y = obj.Y;
            cout <<"Copy Constructor." <<endl;
}
        ~Location()
        {
            cout << X << "," << Y << " Object destroyed." << endl ;
        }
        int  GetX () {
            return X;
}
        int GetY () {
            return Y;
} 
private :
    int X;
    int Y; 
};

//结论1 : 函数的返回值是一个元素 (复杂类型的), 返回的是一个新的匿名对象(所以会调匿名 对象类的copy构造函数)
//
//结论2: 有关匿名对象的去和留
//如果 匿名对象初始化给另外一个同类型的对象, 匿名对象转成有名对象 
//如果 匿名对象赋值给另外一个同类型的对象, 匿名对象被析构

Location g()
{
    Location temp(1, 2);
    return temp;
}  //匿名的对象=temp  匿名对象. 拷贝构造（temp)，然后temp析构
void test1()
{
g(); 
}
void test2()
{
// 匿名对象初始化m 此时c++编译器 直接把匿名对转成m; (扶正) 从匿名转成有名字了m 
//就是将这个匿名对象起了名字m,他们都是同一个对象
Location m = g(); //匿名对象,被扶正,不会析构掉

cout<<m.GetX()<<endl;;
}
void test3()
{
// 匿名对象 赋值给 m2后, 匿名对象被析构
Location m2(1, 2);
m2 = g();   //因为匿名对象=给m2, 匿名对象,被析构

cout<<m2.GetX()<<endl;;
}
int main(void)
{
    test1();
    test2();
    test3();
return 0; 
}

浅拷贝与深拷贝

默认拷贝构造函数
很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了

ps：定义在类里的成员变量 string a：内部会帮你做好深拷贝

#include <iostream>
#include <assert.h>
using namespace std;

class Test {
  public:
    Test()  {
        cout<<"我是无参构造函数，被调了"<<endl; 
        p=new int(10);
        }
     Test(int a)  {
        m_a = a; 
      }
  
    ~Test() {
  cout<<"我是析构函数， 被调了"<<endl; 
  assert(p!=NULL);
            delete p;    //这里会出现异常，因为t2和t1指向同一个堆，一个内存区不能同时delete两次。
  }
        void printT()
        {
            cout << "m_a = " << m_a <<endl;
            
        }

  

    private:
        int m_a;
        int *p;
};


int main(){
  Test  t1;
  Test  t2(t1);   
 
}

使用默认拷贝构造函数都是浅拷贝。 有时候浅拷贝不会发生异常，当涉及动态变量时就可能发生异常。
解决方案: 手工编写拷构造函数 使用深copy
如 在拷贝函数中用new 或 malloc开辟新的内存区来赋值。

这个帖子里，大佬写得很好（https://www.cnblogs.com/alantu2018/p/8459250.html）

构造函数的初始化列表

#include <iostream>
using namespace std;
class ABC
{
public:
    ABC(int a, int b, int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("ABC construct ..\n");
    }
~ABC() {
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("~ABC() ..\n");
    }
private:
    int a;
    int b;
    int c; 
    };

class MyD
{
public:
    MyD():abc1(1,2,3),abc2(4,5,6),m(100)   //构造函数的初始化列表，冒号后面是直接初始化，调用构造函数
    {
        cout<<"MyD()"<<endl;
    }    
    ~MyD() {
        cout<<"~MyD()"<<endl;
    }
private:
    ABC abc1;
    ABC abc2;
    const int m;
};
int main()
 {
MyD myD;
return 0;
 }

构造顺序与初始化列表顺序无关，按构造对象成员的顺序

#######构造中调用构造是危险的行为

#include <iostream>
using namespace std;
//构造中调用构造是危险的行为 
class MyTest
{
public:
    MyTest(int a, int b, int c)
    {
        _a = a;
        _b = b;
        _c = c;
}
    MyTest(int a, int b)
    {
        _a = a;
        _b = b;
    MyTest(a, b, 100); //产生新的匿名对象 ，之后会被析构
    }
    ~MyTest() {
        printf("MyTest~:%d, %d, %d\n", _a, _b, _c);
    }
int getC() 
{
    return _c;
     }
void setC(int val)
{
    _c = val; 
}
private:
    int _a;
    int _b;
    int _c;
     };
int main()
 {
    MyTest t1(1, 2);
    printf("c:%d\n", t1.getC()); //请问c的值是？  答案是乱码
    return 0;
}

new和delete

new int;
 //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)
new int(100); 
//开辟一个存放整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址
new char[10]; 
//开辟一个存放字符数组(包括10个元素)的空间，返回元素的地址
new int[5][4]; 
//开辟一个存放 维整型数组(  为5*4)的空间，返回元素的地址
float *p=new float (3.14159);
 //开辟一个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变量p

new运算符动态分配堆内存
使用形式： 指针变量=new 类型(常量)；
指针变量=new类型[表达式];
作用：从堆分配一块"类型"大小的存储空间，返回首地址
其中：“常量”是初始化值，可缺省
创建数组对象时，不能为对象指定初始值

delete运算符释放已分配的内存空间
使用形式： delete 指针变量;
delete[] 指针变量;
其中：“指针变量”必须是一个new返回的指针

用new分配数组空间时不能指定初值。如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分 配空间是否成功。

malloc不会调用类的构造函数,而new会调用类的构造函数 ！！！！！
Free不会调用类的析构函数，而delete会调用类的析构函数！！！！

静态成员变量和成员函数

静态成员变量

//声明
static 数据类型 成员变量; //在类的内部

//初始化
数据类型 类名::静态数据成员 = 初值; //在类的外部

//调用
类名::静态数据成员
类对象.静态数据成员

1,static 成员变量实现了同类对象间信息共享。
2,static 成员类外存储,求类大小,并不包含在内。
3,static 成员是命名空间属于类的全局变量,存储在 data 区。
4,static 成员只能类外初始化。 初始化后想改的话要通过静态成员函数
5,可以通过类名访问(无对象生成时亦可),也可以通过对象访问。

#include <iostream>
using namespace std;
class Box
{
public:
    Box(int l, int w):length(l),width(w) {
    }
    int volume()
    {
        return length * width * height;
    }
    static int height;
    int length;
    int width;
};

int Box::height = 5;

int main() {
    cout<<Box::height<<endl;
    Box b(1,1);
    cout<<b.height<<endl;
    cout<<b.volume()<<endl;
return 0; 
}

静态成员函数

//声明
static 函数声明
//调用
类名::函数调
类对象.函数调

1,静态成员函数的意义,不在于信息共享,数据沟通,而在于管理静态数据成员, 完 成对静态数据成员的封装。
2,静态成员函数只能访问静态数据成员。原因:非静态成员函数,在调用时this 指 针被当作参数传进。而静态成员函数属于类,而不属于对象,没有 this 指针。

#include <iostream>
using namespace std;
class Student
{
public:
    Student(int n,int a,float s):num(n),age(a),score(s){}
    void total()
    {
count++;
        sum += score;
    }
    static float average();
private:
    int num;
    int age;
    float score;
    static float sum;
    static int count;
};
float Student::sum = 0;
int Student::count = 0;
float Student::average() {    //函数可以在类里面定义，但是不能访问类的对象內的成员，因为this只能用于非静态成员函数内部
    return sum/count;
}
int main() {
    Student stu[3]= {
        Student(1001,14,70),
        Student(1002,15,34),
        Student(1003,16,90)
};
    for(int i=0; i<3; i++) {
        stu[i].total();
}
cout<<Student::average()<<endl;
return 0; 
}

static占用的大小

只有类中的普通成员变量算进类的大小，静态成员变量和函数不算进去。

class C1 {
    public:
        int i;  //4
int j; //4
        int k;  //4
}; //12
class C2 {
    public:
        int i;
        int j;
         int k;
        static int m;                    //4,但不算进去
    public:
        int getK() const { return k; }     //4,但不算进去
        void setK(int val) { k = val; }    //4，但不算进去
};//12

C++类对象中的成员变量和成员函数是分开存储的
成员变量: 普通成员变量:存储于对象中，与struct变量有相同的内存布局和字节对
齐方式
静态成员变量:存储于全局数据区中
成员函数:存储于代码段中。

以下很重要
1、C++类对象中的成员变量和成员函数是分开存储的。C语言中的内存四区模 型仍然有效!
2、C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。
3、静态成员函数、成员变量属于类
4、静态成员函数与普通成员函数的区别 静态成员函数不包含指向具体对象的指针 普通成员函数包含一个指向具体对象的指针

This

#include <iostream>
using namespace std;
class Test {
    public:
        Test(int a, int b) //---> Test(Test *this, int a, int b)
        {
        this->a = a;     //this是一个常指针Test* const this,只指向对象本身，本能再指向其它
        this-> b = b; }
        void printT()
        {
            cout<<"a: " <<a <<endl;
            cout<< "b: " << this->b <<endl;
        }
    protected:
    private:
            int a;
            int b; 
};
int main(void)
{
    Test t1(1, 2);  //===> Test(&t1, 1, 2);
    t1.printT();    // ===> printT(&t1)
    return 0;
 }

（1）若类成员函数的形参和类的属性，名字相同，通过this指针来解决。
（2）类的成员函数可通过const修饰

全局函数和成员函数

Test& add(Test &t2)             //*this //函数返回引用 
 {
this->a = this->a + t2.getA();
this->b = this->b + t2.getB();    
return *this;             //*操作让this指针回到元素状态  //如果想返回一个对象的本身，在成员方法中，用*this返回
}
Test add2(Test &t2)       //*this //函数返回元素 
{
  //t3是局部变量
Test t3(this->a+t2.getA(), this->b + t2.getB()) ;
 return t3;
}

如果想对一个对象连续调用成员方法，每次都会改变对象本身，成员方法需要返回引用。
如：T1.add(t2).add(t2)