[C++知识库]C++---Day04

B+树和B-树的区别？

int main()
{
    int a = 10;
    const int b = 20;
    
    int &x = a;
    const int & y = a;
    
    const int & xb = b;
}

常引用可以引用字面常量，普通变量，常变量

int main()
{
    int a = 10;
    
    const int & b = a;
    //const int* const b = &a;
    
    const int &c = 10;
    //int tmp = 10;
    //const int & c = tmp;
    //const int * const c = tmp;
}

int main()
{
    const int a = 10;
    const int &b = a;
    const int &c = 10;
}

对象可以创建在3个区域：堆区、数据区、栈区

class Object
{
    int value;
 public:
    Object(int x = 0):value(x){}
    void Print()const {cout << value<<endl;}
    ~Object(){}
};

Object g_obj(10);//.data//程序生存期
void fun()
{
    Object obja(20);//.stack//函数生存期
    obja.Print();
}
int main()
{
    Object objb(40);
    fun();
    Object *p = new Object(30);//.heap
    //new此时要完成那几个步骤：（1）申请空间；（2）对这个对象，在空间中创建对象，调动构造函数；（3）把创建好对象的地址返回给p
    //new可以自动计算Obj对象的大小
    p->Print();
    delete p;
}

全局对象的创建和主函数的位置没有关系

一旦进入主函数之前，一定要创建好全局对象

全局对象的生存期：进入主函数之前创建，当整个程序结束时，全局对象才能够销毁

class Object
{
    int value;
 public:
    Object(int x = 0):value(x){cout<<"Create Object:" <<this<<endl;}
    void Print()const {cout << value<<endl;}
    ~Object(){cout <<"Object::~Object"<<this<<endl;}
};
int main()
{
    int n;
    cin>>n;
    Object *s = new Object(n);//1 ---调动构造函数
    Object *p = new Object[n];//n ---动态开辟一组对象 ,此处可以构建对象的前提是有缺省构造函数
    delete[] p;
    
    delete s;
}


int main()
{
    Object objar[10];//调动10次构造函数，以及析构函数
    return 0;
}

拷贝构造函数

拿一个对象初始化另一个对象

class Object
{
    int value;
 public:
    Object(){}
    Object(int x):value(x){}
    ~Object(){}
    void SetValue(int x){value = x;}
    int GetValue()const {return value;}
    
    int& Value(){return value;}
    const int & Value()const {return value;}
    Object(const Object &obj):value(obj.value)
    //去掉引用，会出现什么问题---死递归
    //此处加const---常引用，防止修改
    {
        cout<<"Copy Create"<<endl;
    }
};
Object fun(const Object &obj)
//是否加const，与函数所完成的功能有关，取决于是否想修改传入的参数
//不加const---通过形参去改变实参
{
    int val = obj.GetValue();
    Object obja(val);
    return obja;//调动拷贝构造函数创建将亡值
    //将亡值是存在于赋值语句过程中
}
int main()
{
    Object objx(0);
    Object objy(0);
    objy = fun(objx);
    reurn 0;
}
//此程序运行过程中，创建了多少个对象？---5 

int main()
{
    Object obja(10);
    Object objb(obja);
}

函数的返回类型以及形参不具有静态规则

Object &fun(const Object &obj)
{
    int val = obj.Value()+10;
    Object obja(val);
    return obja;
}
//以引用返回和不以引用返回的区别：
int main()
{
    Object objx(0);
    Object objy(0);
    objy = fun(objx);
    cout << objy.Value() <<endl;
    return 0;
}

eax存放的是将亡值的地址，把eax所指对象的地址给objy赋值

将亡值具有常性

构建将亡值为什么要构建在主函数的栈帧中？—构建在调用者的空间中

不以引用返回：

以引用返回：

static只能修饰函数名，不能修饰函数返回类型，也不能修饰形参列表

vs 2019不允许以引用返回

运算符的重载

class Complex
{
 private:
    double Real,Image;
 public:
    Complex():Real(0),Image(0){}
    Complex(double r,double i):Real(r),Image(i){}
    ~Complex(){}
    //Complex Add(const Complex * const this,const Complex &c)
    Complex Add(Complex c) const
    {
        double r = this->Real + c.Real;
        double i = this->Image + c.Image;
        //Complex tmp(r,i);
        //return tmp;
        return Complex(this->Real+c.Real,this->Image+c.Image);
    }
    //类型名+括号：调动构造函数去构建无名对象
    
    //c3 = c1.Add(c2);
    //c3 = Add(&c1,c2);
    void Print()
    {
        cout << Real << " + " <<Image <<"i"<<endl;
    }
};

int main()
{
    Complex c1(1.2,2.3);
    Complex c2(4.5,5.6);
    Complex c3;
    c3 = c1.Add(c2);
    c3.Print();
}

操作符不能作为函数名称来用

Complex operator+(Complex c) const
{
    double r = this->Real + c.Real;
    double i = this->Image + c.Image;
    //Complex tmp(r,i);
    //return tmp;
    return Complex(this->Real+c.Real,this->Image+c.Image);
}
int main()
{
    Complex c1(1.2,2.3);
    Complex c2(4.5,5.6);
    Complex c3;
    c3 = c1 + c2;
    c3 = c1.operator+(c2);
    c3 = operator+(&c1,c2);
}

对于我们自己设计的类型，系统会默认有6个缺省函数：

class Object
{
    Object() {}
    ~Object() {}
    Object(const Object &x) {}
    //赋值语句的重载
    Object & operator=(const Object &x)
    {
        return *this;
    }
    //取地址符的重载
    Object * operator&() {return this;}
    const Object * operator&()const {return this;}
    
    //c11中新增的
    //移动构造函数
    Object(Object &&x)
    {}
    //移动赋值函数
    Object & operator=(Object &&x)
    {}
}

在C11标准中，变成8个

class Object
{
 private:
    int value;
 public:
    Object(){cout << "Object::Object" <<this <<endl;}
    Object(int x):value(x){cout << "Object::Object:"<<this<<endl;}
    ~Object(){cout << "Object::~Object:"<<this<<endl;}
    Object(const Object& obj):value(obj.value)
    {
        cout << "Copy Create:" <<this <<endl;
    }
    
    Object & operator=(const Object& obj)//此处&：引用
    {
        if(this != &objb)//此处& ：取地址
        {
            this->value = obj.value;
        }
        return *this;
    }
    //obja = obja;operator=(&obja,obja);
    
    Object & operator=(const Object& obj)
    {
        this->value = obj.value;
        return *this;
    }
    //如何防止给自己赋值？obja = obja;
    //operator=(&obja,operator=(&objb,objc)));
    //对象的生存期不受函数影响，可以以引用返回
    
    void operator=(const Object& obj)
    {
        this->value = obj.value;
    }
    //obja = objb = objc;//不可以进行连续赋值
    //obja = objb.operator=(objc);
    //obja = operator=(&objb,objc);
    //赋值语句的重载返回值是无类型，所有不能够进行连续赋值
    int& Value(){return value;}
    const int & Value()const {return value;}
};
int main()
{
    Object objx(0);
    Object objy(0);
    objy = fun(objx);
    reurn 0;
}
//此程序运行过程中，创建了多少个对象？---5 

int main()
{
    Object obja(10);
    Object objb(obja);
}

objc);
//赋值语句的重载返回值是无类型，所有不能够进行连续赋值
int& Value(){return value;}
const int & Value()const {return value;}
};
int main()
{
Object objx(0);
Object objy(0);
objy = fun(objx);
reurn 0;
}
//此程序运行过程中，创建了多少个对象？—5

int main()
{
Object obja(10);
Object objb(obja);
}