小白学习，c++基础（六）

1、new delete

1.1、new给基本类型申请空间

void test01()
{
    //基本类型
    int *p = NULL;
    //p = (int *)calloc(1,sizeof(int));
    //p = new int(100);// *p = 100
    p = new int;
    *p = 100;
    cout<<"*p = "<<*p<<endl;//100
    //释放 free(p)
    delete p;
}

1.2、new申请数组空间

void test02()
{
	int *arr=NULL;
	arr = new int[5];
	int i=0;
	for(i=0;i<5;i++)
	{
		cout<<arr[i]<<" "<<endl;
	}
	delete [] arr;
}

1.3\、new给类对象申请空间

void01()
{
	Person *p = new Person;
	delete p;
}

1.3、尽量不要使用delete释放void*

2、对象数组

2.1本质是数组，只是每个元素的是类的对象

void()
{
	Person arr[5];
}

2.2、如果想让对象数组中的元素调用有参构造 必须认为使用用餐构造 初始化

void test07()
{
    //对象数组 arr1是数组 每个元素是Person类型的对象
    //定义对象数组的时候 系统会自动给 数组中的每个元素 调用构造函数
    //人为 为元素 调用有参构造
    //初始化部分 调用有参构造 为初始化部分自动调用默认构造（无参构造）
    Person arr1[5]={ Person("lucy",18), Person("bob",20)};
    //arr1[0] 第0个元素 就是Person的对象
    arr1[0].showPerson();
    arr1[1].showPerson();
}

3、静态成员 static修饰的成员

成员:成员变量 成员函数
static 修饰成员变量 修饰成员函数
static声明为静态的，称为静态成员。 不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。
静态成员 属于类 而不是对象。

3.1、static 修饰成员变量
静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。
静态成员变量必须在类中声明，在类外定义。
静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。

class Data
{
public:
    int num;//普通成员变量
    static int data;//静态成员变量(类内声明)
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化

void test01()
{
    //data是静态成员变量 是属于类 可以通过类名称::直接访问
    cout<<Data::data<<endl;//100
    //赋值
    Data::data = 200;
    cout<<Data::data<<endl;//200

    //data静态变量 是所有对象 共享的 可以通过对象名访问
    Data ob1;
    ob1.data = 300;
    cout<<Data::data<<endl;//300

    Data ob2;
    cout<<ob2.data<<endl;//300

    //普通成员变量 属于对象的 只能通过对象名访问
    ob1.num = 100;
    cout<<"ob2.num = "<<ob2.num<<endl;//随机值
    //cout<<Data::num<<endl;//普通成员变量不能通过类名称访问
}

3.2、static修饰静态成员函数

class Data
{
private:
    int num;//普通成员变量
    static int data;//静态成员变量(类内声明)
public:
    //普通成员函数 依赖于 对象的 必须对象调用
    int getData(void)
    {
        return data;
    }

    //静态成员函数  属于类 而不属于对象
    static int getDataStatic(void)
    {
        return data;
    }
};

//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化

void test01()
{
    //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
    //cout<< Data::getData()<<endl;//err getData() 必须对象调用

    Data ob;
    cout<<ob.getData()<<endl;
    //存在问题：data静态的 在创建对象之前 就已经存在
    //如果类没有实例化对象 难道 就不能使用data了吗？
    //解决上述问题 就要用到静态成员函数

    //1、静态成员函数 属于类 就可以通过类名称直接访问
    cout<<Data::getDataStatic()<<endl;

    //2、也可以通过对象名访问（对象共享静态成员函数）
    cout<<ob.getDataStatic()<<endl;
}

注意事项：1静态成员函数的目的，操作静态成员数据
2、静态成员函数 不能访问 非静态成员数据（静态成员函数内部没this指针）
3、普通成员函数可以操作静态成员函数 和 非静态成员函数

3.3、const 修饰静态成员
如果一个类的成员，既要实现共享，又要实现不能被修改，就要用static const修饰

class Data
{
public:
    const static int data;//静态成员变量(类内声明)
public:
    //静态成员函数  属于类 而不属于对象
    static int getDataStatic(void)
    {
        //num = 200;//err 静态成员函数 不能访问普通成员变量
        return data;
    }
};

//定义的时候 不需要加static
const int Data::data=100;//类外定义+初始化

void test02()
{
    //访问
    cout<<Data::data<<endl;
    //赋值
    //Data::data = 200;//err data静态成员只读
    cout<<Data::data<<endl;
}

4、this指针

c++的封装性：将数据 和 方法 封装在一起
数据 和 方法 是分开存储。
每个对象 拥有独立的数据.
每个对象 共享同一个方法。
4.1 this指针引入

class Data
{
public:
    int m_num;

    void setNum(int num)
    {
        m_num = num;
    }

};

void test01()
{
    Data ob1;
    ob1.setNum(10);
    cout<<"ob1.m_num = "<<ob1.m_num<<endl;

    Data ob2;
    ob2.setNum(20);
    cout<<"ob2.m_num = "<<ob2.m_num<<endl;

    Data ob3;
    ob3.setNum(30);
    cout<<"ob3.m_num = "<<ob3.m_num<<endl;
}

class Data
{
public:
    int m_num;

    void setNum(int num)
    {
        //m_num = num;
        this->m_num = num;
    }
};

void test01()
{
    Data ob1;
    ob1.setNum(10);
    cout<<"ob1.m_num = "<<ob1.m_num<<endl;

    Data ob2;
    ob2.setNum(20);
    cout<<"ob2.m_num = "<<ob2.m_num<<endl;

    Data ob3;
    ob3.setNum(30);
    cout<<"ob3.m_num = "<<ob3.m_num<<endl;
}

注意事项：1、this指针是隐含在对象成员函数内的一种指针
2、成员函数通过this指针即可知道操作的是那个对象的数据
3、静态成员函数内部没有this指针，静态成员函数不能操作非静态成员变量（静态成员函数 是属于类 函数内部 没有this指针）
4.2 this指针的使用
4.2.1 当形参和成员变量同名时，可用this指针来区分

class Data
{
public:
    int num;

    //形参 和成员名相同
    void setNum(int num)
    {
        //形参num
        //成员num  this->num
        //num= num;//就近原则 形参num 赋值给 形参num
        this->num = num;
        //将形参num 赋值给 对象中成员num
    }
};

4.2.2 在类的普通成员函数中返回对象本身（*this）（重要）

class MyCout
{
public:
    MyCout& myCout(char *str)
    {
        cout<<str;
        return *this;//*this 代表就是 当前调用该函数的对象
    }
};
int main(int argc, char *argv[])
{
    MyCout ob;
    /*
    ob.myCout("hehe");
    ob.myCout("haha");
    ob.myCout("xixi");*/
    
    ob.myCout("hehe").myCout("haha").myCout("xixi");//ob.myCout("hehe") == ob

    return 0;
}