布尔类型和引用的本质

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

bool类型内部是由一个字节的整型&＃xff08;byte&＃xff09;实现的&＃xff0c;所以支持运算
输出结果&＃xff1a; 0 1 1

布尔类型是C&＃43;&＃43;中的基本数据类型

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

用C语言编译器编译是错误的&＃xff0c;三目运算符那一行报错&＃xff0c;等号左边是一个值
用C&＃43;&＃43;编译器编译&＃xff0c;编译通过&＃xff0c;打印了&＃xff1a;a&＃61;3&＃xff0c;b&＃61;2

修改&＃xff1a;

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




b使用类型float&或者其他任何不是int&的类型初始化b&＃xff0c;都会报错
如果&＃xff1a;int& b&＃61;1&＃xff0c;也会报错。

阶段性小结

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

引用的意义&＃xff1a;

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


普通引用不能初始化为常量&＃xff0c;但是const引用却可以初始化为常量

#include void Example()
{printf("Example:\n");int a &＃61; 4;const int& b &＃61; a;int* p &＃61; (int*)&b;//b &＃61; 5;//报错*p &＃61; 5;printf("a &＃61; %d\n", a);printf("b &＃61; %d\n", b);
}void Demo()
{printf("Demo:\n");const int& c &＃61; 1;int* p &＃61; (int*)&c;//c &＃61; 5;//报错*p &＃61; 5;//将c变量所代表的四字节的空间存储的值从1改变成5&＃xff0c;合法操作printf("c &＃61; %d\n", c);
}int main(int argc, char *argv[])
{Example();printf("\n");Demo();return 0;
}

18行 ref.r 和12行 TRef ref &＃61; { c }&＃xff1b;说明 r 是 c 的别名ref.r就是c&＃xff0c;所以是1
sizeof( TRef )&＃61;4&＃xff0c;为啥&＃xff1f;解释如下&＃xff1a;

引用的本质是指针&＃xff0c;所以大小是个指针大小&＃xff1a;4

#include struct TRef
{char* before;char& ref;char* after;
};int main(int argc, char* argv[])
{char a &＃61; &＃39;a&＃39;;char& b &＃61; a;char c &＃61; &＃39;c&＃39;;TRef r &＃61; {&a, b, &c};printf("sizeof(r) &＃61; %d\n", sizeof(r));printf("sizeof(r.before) &＃61; %d\n", sizeof(r.before));printf("sizeof(r.after) &＃61; %d\n", sizeof(r.after));printf("&r.before &＃61; %p\n", &r.before);printf("&r.after &＃61; %p\n", &r.after);return 0;
}


after的地址减去before的地址是8&＃xff0c;而before本身4个字节&＃xff0c;所以ref也是4个字节&＃xff08;8-4&＃61;4&＃xff09;
证明了&＃xff1a;引用占用4字节空间。

#include
//不要返回局部变量的引用&＃xff0c;相当于返回局部变量的地址??
int& demo() //返回&＃xff1a;int* const&＃61;int&
{int d &＃61; 0;printf("demo: d &＃61; %d\n", d);return d;//return &d
}int& func()
{static int s &＃61; 0;//不会因为函数结束而摧毁printf("func: s &＃61; %d\n", s);return s;//return &s
}int main(int argc, char* argv[])
{int& rd &＃61; demo();int& rs &＃61; func();printf("\n");printf("main: rd &＃61; %d\n", rd);//demo结束后&＃xff0c;变量空间被摧毁&＃xff0c;rd所代表的空间因为函数结束被摧毁&＃xff0c;rd沦为野指针printf("main: rs &＃61; %d\n", rs);printf("\n");rd &＃61; 10;//对野指针指向的地方赋值&＃xff0c;很危险rs &＃61; 11;demo();func();printf("\n");printf("main: rd &＃61; %d\n", rd);printf("main: rs &＃61; %d\n", rs);printf("\n");return 0;
}


编译&＃xff0c;警告&＃xff1a;demo函数返回局部变量
不管警告&＃xff0c;运行&＃xff1a;

小结