c++对c的扩展（1）c和c++的比较

知识点1.【c++语法检查增强】

知识点2.【c++对结构体的增强】

1、c中定义结构体变量需要加上struct关键字，c++不需要
2、c中的结构体只能定义成员变量，不能定义成员函数。c++即可以定义成员变量，也可以定义成员函数

C语言：
struct stu
{
    int num;
    char name[32];
/* c语言 不允许在结构体中  定义成员函数
    void func(void)
    {
        printf("我是结构体中的func");
    }
    */
};
void test01()
{
    //C语言必须加struct
    struct stu lucy = {100, "lucy"};
}

c++语言：
struct stu
{
    int num;
    char name[32];

    //c++语言 允许在结构体中  定义成员函数
    void func(void)
    {
        printf("我是结构体中的func");
    }
};
void test01()
{
    //C++语言不用加struct
    stu lucy = {100, "lucy"};
    
    //调用结构体中的成员方法（成员函数）
    lucy.func();
}

知识点3.【c++新增bool类型】

c++代码：
void test02()
{
    bool mybool;
    cout<<"sizeof(bool) = "<<sizeof(bool)<<endl;//1字节
    mybool = false;
    cout<<"false = "<<false<<endl;//0
    cout<<"true = "<<true<<endl;//1
}
结果：
sizeof(bool) = 1
false = 0
true = 1

知识点4.【三目运算符功能增强】a>b?a:b

1、c语言三目运算表达式返回值为数据值，为右值，不能赋值

void test02()
{
    int a = 10;
    int b = 20;
    printf("C语言:%d\n", a>b?a:b);//20

    //a>b?a:b整体结果 右值（不能被赋值）
    a>b?a:b = 100;//err不能被赋值
}

2、c++语言三目运算表达式返回值为变量本身(引用)，为左值，可以赋值

void test02()
{
    int a = 10;
    int b = 20;
    cout<<"c++中:"<<(a>b?a:b)<<endl;

    //a>b?a:b整体结果是变量本身(引用) 左值（能被赋值）
    a>b?a:b = 100;//b =100
}

能被赋值的就是左值 不能被赋值的就是右值

知识点5.【c++中const】

1、c语言中的const

const int a = 10;//不要把a看成常量
//a的本质 是变量 只是 只读变量

c语言的const修饰全局变量 默认是（外部链接的）

fun.c
//c语言的const修饰全局变量 默认是（外部链接的）
//外部链接:其他源文件 可以使用
const int num = 100;//只读的全局变量 内存放在文字常量区（内存空间只读）

main.c
//对fun.c中的num进行声明(不要赋值)
extern const int num;

void test03()
{
    printf("num = %d\n",num);
    //num = 200;//err num只读

    //C语言中const 修饰变量名 说明变量名为只读（用户不能通过变量名data进行赋值）
    const int data = 100;//局部只读变量 内存在栈区（内存可读可写）
    //data = 200;//err  const修饰变量名 说明变量名为只读

    printf("data = %d\n",data);//100
    //但是：如果知道data的地址 可以通过地址间接的修改data所对应空间的内容
    int *p = (int *)&data;
    *p = 2000;
    printf("data = %d\n",data);//ok 200
}

总结：在C语言中：
1、const修饰全局变量num 变量名只读 内存空间在文字常量区（只读）、不能通过num的地址 修改空间内容
2、const修饰局部变量data 变量名只读 内存空间栈区（可读可写），可以通过data地址 间接的修改空间内容

2、c++中的const 深入理解

fun.cpp

//const修饰的全局变量 默认是内部链接（只在当前源文件有效 不能直接用于其他源文件）
//const int num = 100;
//如果必须用在其他源文件 使用只读的全局变量 必须加extern将num转换成外部链接
extern const int num = 100;

main.cpp

代码：
//声明
extern const int num;
struct Person
{
    int num;
    char name[32];
};
void test04()
{
    cout<<"全局num = "<<num<<endl;//err 不识别num

    //1、c++中 对于基础类型 系统不会给data开辟空间 data放到符号表中
    const int data = 10;
    //data = 100;//err 只读
    cout<<"data = "<<data<<endl;
    //2、c++中当 对data 取地址的时候 系统就会给data开辟空间
    int *p = (int *)&data;
    *p = 2000;
    cout<<"*p = "<<*p<<endl;//空间内容修改成功 2000

    cout<<"data = "<<data<<endl;//data 还是10为啥？如上图，在符号表里取得

    //3、当以变量的形式 初始化 const修饰的变量 系统会为其开辟空间
    int b = 200;
    const int a= b;//系统直接为a开辟空间 而不会把a放入符号表中
    p = (int *)&a;
    *p = 3000;
    cout<<"*p = "<<*p <<endl;//3000
    cout<<"a = "<<a <<endl;//300

    //4、const 自定义数据类型(结构体、对象) 系统会分配空间
    const Person per = {100,"lucy"};
    //per.num = 1000;//err
    cout<<"num = "<<per.num<<", name = "<<per.name<<endl;//100 lucy
    Person *p1 = (Person *)&per;
    p1->num = 2000;
    cout<<"num = "<<per.num<<", name = "<<per.name<<endl;//2000 lucy
}
运行结果：
全局num = 100
data = 10
*p = 2000
data = 10
*p = 3000
a = 3000
num = 100, name = lucy
num = 2000, name = lucy

总结：c++总结
1、const int data = 10；//data先放入符号表
2、如果对data取地址 系统才会给data开辟空间
3、const int a = b;//b是变量名 系统直接给a开辟空间 而不放入符号表
4、cosnt 修饰自定义数据 系统为自定义数据开辟空间

知识点6.【尽量const替换#define】

1、宏没有类型 const有

#define MAX 1024
const short my_max =1024;
void func(short i)
{
    cout<<"short函数"<<endl;
}
void func(int i)
{
    cout<<"int函数"<<endl;
}
void test05()
{
    func(MAX);//int函数

    func(my_max);//short函数
}

2、宏的作用域是整个文件 const的作用域 以定义情况决定

void my_func(void)
{
    //作用范围 是当前复合语句
    const int my_num = 10;

    //作用范围 当前位置 到文件结束
    #define MY_NUM 10
}
void test06()
{
    //cout<<"my_num = "<
    cout<<"MY_NUM = "<<MY_NUM<<endl;//ok 能识别
}

3、宏不能作为命名空间的成员 const可以

namespace A {
    // const可以作为成员
    const int my_a=100;

    //MY_A 属于文件 不属于A
    #define MY_A 200
}
void test07()
{
    cout<<"my_a = "<<A::my_a<<endl;
    //cout<<"MY_A = "<
    cout<<"MY_A = "<<MY_A<<endl;
}