布尔类型和引用的本质

C语言里面不存在真正的bool类型，0代表假，1代表真，功能上可行，但是不严谨

bool类型内部是由一个字节的整型（byte）实现的，所以支持运算
输出结果： 0 1 1

布尔类型是C++中的基本数据类型

• 可以定义bool类型的全局变量
• 可以定义bool类型的常量
• 可以定义bool类型的指针
• 可以定义bool类型的数组

用C语言编译器编译是错误的，三目运算符那一行报错，等号左边是一个值
用C++编译器编译，编译通过，打印了：a=3，b=2

修改：

编译报错，与之前C语言报的错一样，因为左边返回的是常量了。C++编译器只有在全部是变量的情况下可以作为左值！




b使用类型float&或者其他任何不是int&的类型初始化b，都会报错
如果：int& b=1，也会报错。

阶段性小结

• bool类型是C++新增加的基础类型
• bool类型的值只能是true和false
• C++中的三目运算符可作为左值使用
• C++中的引用可以看作变量的别名来使用
• 三目运算符的可能返回值都是变量时，返回的是引用

引用的意义：

函数定义的时候不需要初始化，而在使用函数时会将外部实际变量传入函数，此时相当于引用初始化


普通引用不能初始化为常量，但是const引用却可以初始化为常量

#include <stdio.h>

void Example()
{
    printf("Example:\n");
    
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
    
    //b = 5;//报错
    
    *p = 5;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
}

void Demo()
{
    printf("Demo:\n");
    
    const int& c = 1;
    int* p = (int*)&c;
    
    //c = 5;//报错
    
    *p = 5;//将c变量所代表的四字节的空间存储的值从1改变成5，合法操作
    
    printf("c = %d\n", c);
}

int main(int argc, char *argv[])
{
    Example();
    
    printf("\n");
    
    Demo();

    return 0;
}

18行 ref.r 和12行 TRef ref = { c }；说明 r 是 c 的别名ref.r就是c，所以是1
sizeof( TRef )=4，为啥？解释如下：

引用的本质是指针，所以大小是个指针大小：4

#include <stdio.h>

struct TRef
{
    char* before;
    char& ref;
    char* after;
};

int main(int argc, char* argv[])
{
    char a = 'a';
    char& b = a;
    char c = 'c';

    TRef r = {&a, b, &c};

    printf("sizeof(r) = %d\n", sizeof(r));
    printf("sizeof(r.before) = %d\n", sizeof(r.before));
    printf("sizeof(r.after) = %d\n", sizeof(r.after));
    printf("&r.before = %p\n", &r.before);
    printf("&r.after = %p\n", &r.after);

    return 0;
}

after的地址减去before的地址是8，而before本身4个字节，所以ref也是4个字节（8-4=4）
证明了：引用占用4字节空间。

#include <stdio.h>
//不要返回局部变量的引用，相当于返回局部变量的地址??
int& demo() //返回：int* const=int&
{
    int d = 0;
    
    printf("demo: d = %d\n", d);
    
    return d;//return &d
}

int& func()
{
    static int s = 0;//不会因为函数结束而摧毁
    
    printf("func: s = %d\n", s);
    
    return s;//return &s
}

int main(int argc, char* argv[])
{
    int& rd = demo();
    int& rs = func();
    
    printf("\n");
    printf("main: rd = %d\n", rd);//demo结束后，变量空间被摧毁，rd所代表的空间因为函数结束被摧毁，rd沦为野指针
    printf("main: rs = %d\n", rs);
    printf("\n");
    
    rd = 10;//对野指针指向的地方赋值，很危险
    rs = 11;
    
    demo();
    func();
    
    printf("\n");
    printf("main: rd = %d\n", rd);
    printf("main: rs = %d\n", rs);
    printf("\n");
    
    return 0;
}

编译，警告：demo函数返回局部变量
不管警告，运行：

小结