类和对象

类和对象

构造函数

默认构造函数

class会自动生成一个默认构造函数，当手写一个构造函数（包括拷贝构造）时，默认构造函数会失效（如何失效？）

拷贝构造函数

class date
{
        public:
        date(int year=1,int month=1,int day=1)//缺省
        {
                _year=year;
                _month=month;
                _day=day;
        }
    
        date(const date& d)//拷贝构造
        {
                _year=d._year;
                _month=d._month;
                _day=d._day;
        }
           
        private:
        int _year;
        int _month;
        int _day;

};

传值传参的传值返回的时候会调用拷贝构造

深拷贝

当需要手写析构函数（开空间）的时候，需要手写拷贝构造

浅拷贝

默认的拷贝

初始化列表

原算符重载

重载赋值=

        date &operator= (const date& d)
        {
                if(this!=&d)
                {
                        _year=d._year;

                }
                        return *this;
        }

使用date类型是为了满足d1=d2=d3这种连续赋值的情况

const date& d中的取地址是为了减少一次拷贝构造

date &operator中的&同样也是为了出了this的作用域减少拷贝构造

this!=&d防止自己给自己赋值

深拷贝需要手写赋值重载

        date d1{2021,8,1};
        date d2{2021,1,1};
        d1=d2;//赋值重载
        date d3=d1;//拷贝构造

区别在于是否初始化过

自定义后置++

a++

date operator++(int)//多一个参数（只能是int）形成重载，为了区分前置++
{
	date tmp(*this);
	*this+=1;
	return tmp;
}

++a,前置开销小

date &operator++()
{	
	*this+=1;
	return *this;
}

友元重载输入和输出流

friend ostream& operator<<(ostream& out,const date &d)
    

输出

	ostream &operator<<(ostream& out，const  date &d)
{
	out<<d._year<<d._month<<d._day;
    return out;//返回ostream类型可以实现连续输出
}

输入

instream &operator (instream&in ,date &d)
{
	in>>d._year>>d._month>>d._day;
    return in;
}

const

当我在main函数中想用const修饰一个类

eg:

class A
{
    void print()//默认的第一个参数是this,const传入的参数应该是
    {//const * this
		cou<<"123"<<endl;
    }
}

int main()
{
	const A aa;
    aa.print();
}

此时的函数调用会出现权限放大，不能正常运行

修改后

    void print()const//const 修饰*this
    {//this的类型变为const A*
		cou<<"123"<<endl;
    }

初始化列表

在成员变量定义的地方

#include<iostream>
using namespace std;

class Date
{
        public:
        //对象调用构造函数，初始化列表是他所有成员函数初始化的地方
        //不管是否显示的写初始化列表，编译器都会去初始化列表初始化

        //      const，int&(引用)，没有默认构造的自定义类型必须在初始化列表初始化
        //不在 初始化列表 初始化 的自定义类型 只会调用他的默认构造函数
        Date(int year,int month,int day)
        :_year(2000)
        ,_month(month)
        ,_day(day)
        {

        }

          
        int _year;//声明
        int _month=3;//缺省值
        int _day;
        
        //const int_a;
        //const类型需要在定义的时候初始化
        // 默认生成的构造函数对内置类型不做处理，对自定义类型调用他的拷贝构造,而const int 属于内置类型
};

int main()
{
        Date d{1,1,1};//对象整体的 定义
}

成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，与初始化列表的次序无关

explicit

防止单参数的构造函数发生隐式类型和转换

class DATE
{
	public:
    explicit DATE(int year)
        :_year(year)
    {
		//_year=year;
    }
    private:
    int _year;
}

#include<iostream>
using namespace std;

class Date
{
        public:

        Date(int year,int month,int day)
        :_year(year)
        ,_month(month)
        ,_day(day)
        {

        }
        Date(int year)
        :_year(year)
        {

        }
        
        int _year=0;//声明
        int _month=0;//缺省值
        int _day=0;
};

int main()
{
        Date dd(1);//构造函数
        Date dd2=1;//c++98 支持隐式单参数类型转换     构造+拷贝+优化——>构造

        Date d(1,1,1);//构造函数
        Date d2{2,2,2};//c++11 支持多参数隐式类型转换
        cout<<d._year<<endl;
}

static成员

静态成员变量

在类中写static属于整个类而不是某一个对象，在静态区

类内声明，全局区定义初始化int Date::count=0;

静态成员函数

静态成员函数没有this指针，一般在配合静态成员变量时使用

静态成员函数不能访问非静态成员（因为没有this指针）

友元

我的是我的，你的也是我的，不传递，不继承，

内部类

假设B是A的内部类

B跟A空间独立，只是受到作用域限制

B是A的友元