嘀嘀咕 （1）

目录

• 1.三目运算符(可以当左值)
• 2.const增强
  • c：伪常量
  • c++：
  • 与宏定义区别：
• 3.引用
  • 引用是个常指针；有内存空间(常量区上，反正不在栈上)
  • 使用时当作变量的别名
  • 引用作为返回值，不要返回局部变量的引用
  • 指针引用 用做函数参数
  • 常引用(目的：禁止通过修改引用值来改变被引用的对象)

1.三目运算符(可以当左值)

c中：
int a = 10;
int b = 20;
(a<b?a:b) = 30;    //err

*(a<b?&a:&b) = 30;

2.const增强

c：伪常量

const int a = 10;

int array[a] = {0};    //err

int *p = &a;
*p = 20;    //a = 20

c++：

const int a = 10;    

int array[a] = {0};    //ok

int *p = (int *)&a;
*p = 20;    //a = 10

c++中的const并不为其分配空间，而是在符号表中。
如果对一个常量取地址，编译器会临时开辟一个空间temp。让这个指针存放这个临时空间的地址

与宏定义区别：

const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器处理，单纯的文本替换

3.引用

引用是个常指针；有内存空间(常量区上，反正不在栈上)

使用时当作变量的别名

struct typeA
{
    int *a;
}

struct typeB
{
    int &a;
}

sizeof(typedA) == sizeof(typdeB)  == 4

int &a    <===>   int *const a;

引用作为返回值，不要返回局部变量的引用

int& getA( )
{
    int a = 10;
    return a;
}

int &A = getA( );    
cout<<A<<endl;    //乱码    A是局部变量a的别名

//引用作为返回值，可以作为左值
int& getB( )
{
    static int a  =10;
    return a;
}

getB( ) = 100;

指针引用 用做函数参数

struct  Teacher
{
    char  name[64];
    int  age  ;
};

int  getTeacher(Teacher  **p)
{
    Teacher  *tmp  =  NULL;
    if  (p  ==  NULL)
    {
        return  ‐1;
    }
    tmp  =  (Teacher  *)malloc(sizeof(Teacher));
    if  (tmp  ==  NULL)
    {
        return  ‐2;
    }
    tmp‐>age  =  33;
 
    *p  =  tmp;
    return  0;
}


int  getTeacher2(Teacher*  &myp)
{
    //给myp赋值  相当于给main函数中的pT1赋值
    myp  =  (Teacher  *)malloc(sizeof(Teacher));
    if  (myp  ==  NULL)
    {
        return  ‐1;
    }
    myp‐>age  =  36;
    return  0;
}

void  FreeTeacher(Teacher  *pT1)
{
    if  (pT1  ==  NULL)
    {
        return  ;
    }
    free(pT1);
}

int  main(void)
{
    Teacher  *pT1  =  NULL;
    //1  c语⾔言中的二级指针
    getTeacher(&pT1);
    cout<<"age:"<<pT1‐>age<<endl;
    FreeTeacher(pT1);

    //2  c++中的引⽤用  （指针的引⽤用）
    //引⽤用的本质  间接赋值后2个条件  让c++编译器帮我们程序员做了。
    getTeacher2(pT1);
    cout<<"age:"<<pT1‐>age<<endl;
    FreeTeacher(pT1);
    return  0;
}

常引用(目的：禁止通过修改引用值来改变被引用的对象)

const int & e   =====  const int * const e

常量（字面量）对const引用进行初始化时，C++编译器会为常量值
分配空间，并将引用名作为这段空间的别名
const  int  &m  =  43;                      //c++编译器  会  分配内存空间
                                            //  int  temp  =  43
                                            //  const  int  &m  =  temp;