c++第三天（引用和动态内存分配）

一、引用

int &xm = mm； 数据类型 &别名 = 原名；

转换以后实际上别名和原名地址一模一样，无论修改那个变量的值，另一个都会更改。（引用一般都是用于参数传递的！相当于地址传递 ）

例子：交换函数

void swap(int &a,int &b) //引用格式

{int temp = a;

a = b;

b = temp;}

int main()

{int a=10; int b=20;

swap(a,b); //直接传名字}

//demo1.cpp   对引用的进一步使用

#include<iostream>
using namespace std;

int add(int &p1,int &p2)    //传递变量，用&引用
{
    int c = p1 + p2; 
    return c;     //返回两数相加的值
}

int add2(int &&p1,int &&p2) //传递常量，用双重&&引用
{
    return p1+p2;  //返回两数相加的值
}

int main()
{
    //short s;   int &ss = s; //引用类型必须和引用的对象类型一致

    int &&w = 100;       //给常数100取别名为w
    const int &p = 200;  //给常数200取别名为p

    int a=10,b=20; 
    int c = add(a,b);   //传递值，函数引用值

    int d = add2(300,400);  //常量传递，用&&引用接收

    cout << c << endl << w << endl << p << endl;    //打印结果
    cout << d << endl;  //打印结果
}

//demo2.cpp  对函数的引用

#include<iostream>
using namespace std;

//该函数返回值是一个引用
int &func(int &&a,int &b)
{
    return a;
}
//引用函数可以作为左值
int &func_2()
{
    static int data = 10086;  //函数内数据的形参需要申请空间
    return data;
}

int func_3()
{
    int a=11,b=22;
    return a+b;
}

int main()
{

    int j=11,k=23;
    cout << func_2() << endl;   //返回引用函数的值

    cout << func_3() << endl;   //正常函数返回值

    int a=10,b=20;
    int &p = func(100,b);  //引用函数，引用作为返回值
    cout << p <<endl;
}

//demo3.cpp  结构体函数引用

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

//结构体1
struct stu
{
    char *p = new char[10];
    int *age = new int[10];
    int *id = new int[10];
};

//结构体2
struct stt 
{
    int age;
    int id;
    char name[10];
};

//引用函数1
struct stu &init_stu(struct stu &q)
{
    // q.p = "小明";
    strcpy(q.p,"小明");
    *q.age = 18;
    *q.id = 10086;   
    return q; 
};

//引用函数2
struct stt &init_stu2(struct stt &h)
{
    strcpy(h.name,"小东");
    h.age = 19;
    h.id = 10010;
    return h;
}

int main()
{
    cout <<"学生1信息:\n"; 
    struct stu q;
    cout << init_stu(q).p  << endl;
    cout << *init_stu(q).age << endl;
    cout << *init_stu(q).id << endl;

    cout <<"学生2信息:\n"; 
    struct stt h;
    cout << init_stu2(h).name << endl;
    cout << init_stu2(h).age << endl;
    cout << init_stu2(h).id << endl;
   
}

引用的注意事项 ：

1、引用必须初始化 （引用就是取别名，目标都没有哪里来别名？）。 int &a; //错误 。

2、引用被初始化后，无法修改引用的目标 。

3、对一个常量数据进行引用必须添加 const 例如: const int &tmp = 100;

4、引用的类型必须要一致 。 short s=10010; int &ss = s; //错误的，引用的类型不一致。

5、常量引用不能修改目标的值！

二、动态内存分配

数据类型 *变量名 = new 数据类型；

int *p = new int; //自动计算数据类型大小； 自动转换地址类型

int p1 = new int(100) ; 自动初始化空间内容

因此new分配动态内存(堆空间) 比起malloc更加方便

//释放一块动态内存 delete 变量名；

例如：delete p； delete p1； new分配100个int类型空间

int *p = new int[100]；//分配空间

初始化：int *p = new int[100]{10,20,30,40};

//demo3.cpp  对数组动态内存分配

#include<iostream>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
using namespace std;

int main()
{
    int k;
    int *p = new int[100]{10,20,30,40,50,213,100};

    int *q = p;
    for(k=0;*q!='\0';k++,q++);  //定义一个指针指向数组p，通过遍历将数组长度计算出来
    
    for (int i = 0; i < k; i++)
    {
        cout << p[i] << endl;
    }

    delete []p;
   
    char *p1 = new char[1024]; //char类型初始化不能用字符串
    strcpy(p1,"world hello!");  //通过strcpy函数进行字符串赋值
    cout << p1 << endl;
    delete []p1;
    
    
}

//demo4.cpp  引用的使用定义

#include<iostream>
#include<stdlib.h>
#include<unistd.h>
using namespace std;

int main()
{

#if 0
    int *p = (int *)malloc(sizeof(int)*100);
    *p = 100;
    cout << *p << endl;
#endif

    int *p = new int(1000);
    char *q = new char('h');
    char **h = new char*("world hello");
    float *k = new float(20.2);
    struct node 
    cout << "*h=" << *h <<"  *p="<< *p << "  *q="<< *q << "  *k=" << *k <<endl;
    delete p;
    delete q;
    delete *h; //双指针释放需解引用地址
    delete k;
    
}

//demo6.cpp  常量的引用规范

#include<iostream>

using namespace std;

int main()
{
    int a=10;
    int b=20;
    int &p = a;
    cout << p << endl;
    // int &p = b; 引用指向了对象之后，就不能修改引用对象
    p = b;

    const int &re_a = a;  
    // re_a = 30;  错误，常量引用不能修改值
    cout << p << endl;
    cout << a << endl;
}

二维动态数组： int (*p)[3] = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}}；//不能直接**定义和初始化

额外资料：

1、既有全局变量又有局部变量，局部变量优先 。当出现：：命名空间时，全局变量优先 。

例如 ::value;   //c++特有的空间，此时全局变量优先。

2、问：c++如何获取最大堆空间的分配 ？

答：用while(1)循环每次申请一定的空间，直到堆空间分配失败(返回值为NULL)。