一、C语言

1.全局变量检测

  int a;
  int a=10  
  //C语言允许通过

2.函数检测

 getRects(int w,int h)  //没有返回值 没有形参类型
{
    return w*h; 
}
void test()
{
    getRects(10,10,10);//传参个数不严谨 可以通过
}//C语言允许通过

3.类型转换检测

 void test02()
 {
     char *p=malloc(64);
     //char* 和（void *）malloc 不等
 } //C语言允许通过

4.struct

 struct Person
 {
     int age;
     //void func(); C语言下结构体中不可以放函数
 }
 ---------------------------------------------------------
 void test03()
 {
     struct Person p1; //C语言声明结构变量 必须加上关键字struct
     p1.age=17;
 }

5.bool类型 C语言下没有bool类型

6.三目运算符

  void test05()
  {
      int a=10;
      int b=20;
      printf("ret=%d\n",a>b?a:b);
      a>b?a:b=100;  //NO  C语言下不允许通过，三目运算符返回的是值，相当于20=100
      *（a>b?&a:&b)=100; //YES  C语言方式 可以通过
      printf("a=%d\n",a);
      printf("b=%d\n",b);
  }

7.const

  const int m_A=100;  //全局const修饰变量 收到常量区保护 
  void test06()
  {
      m_A=200;//不可以直接修改
      int * p=&m_A;
      *p=200; //语法通过，运行阶段报错
      
      const int m_B=100; //不可直接修改
      int * p2=&m_B;
      *p2=200;     //局部const修饰的变量可以间接修改成功
      printf("m_B =%d\n ",m_B)；//m_B=200
      
      int arr[m_B];//不可以用来初始化数组  m_B是一个值
  }

8.const在C语言下默认是外部链接属性

 创建test.c文件 并且编写const int m_A=10;
 void test07   
 {
     extern const int m_A;
     printf("a =%d\n ",m_A);   //在C语言中 没有包含头文件test.c编译器可找到该文件
 }

二、C++

1.全局变量检测增强

 int b;
 int b=20;
 //C++不允许通过

2.函数检测增强，形参变量类型检测增强,函数声明的返回值检测增强，函数返回值检测增强，调用时候参数传入个数检测增强

 int getRects(int w,int h)
{
    return w*h; 
}
void test()
{
    getRects(10,10);
}

3.类型转换增强

 void test02()
 {
     char *p=（char *）malloc(64);

 } //C++强制转换后才可通过

4.struct增强

 struct Person
 {
     int age;
     void func();//C++语言下 结构体可以放函数
 }
void test03()
 {
     Person p1; //C++声明结构变量 可以省略关键字struct
     p1.age=17;
 }

5.bool类型

    //bool代表真和假 真-true=1，假-false=0
    bool flag=true;
    void test04()
    {
        cout<<"sizeof bool = "<<sizeof(bool)<<endl; //结果为1
        cout<<"flag = "<<flag<<endl;//打印1或0
    }

6.三目运算符增强

  void test05()
  {
      int a=10;
      int b=20;
      cout<<"ret = "<<(a>b?a:b)<<endl;
      a>b?a:b=100;  //C++允许通过，三目运算符返回的是变量
      cout<<"a= "<<a<<endl;
      cout<<"b="<<b<<endl;
  }

7.const

  const int m_A=100;  //全局const修饰变量 收到常量区保护 
  void test06()
  {
      m_A=200;//不可以直接修改
      int * p=（int *)&m_A; //const 类型强转
      *p=200; //语法通过，运行阶段报错
      
      const int m_B=100; 
      m_B=200;//不可直接修改
      int * p2=&m_B;
      *p2=200;     //局部const修饰的变量 间接修改语法通过 不能修改其值
      cout<<"m_B = "<<m_B<<endl;//m_B=100;
      
      int arr[m_B];//可以用来初始化数组  是一个常量
  }

8.const在C++下默认是内部链接属性

 创建test.cpp文件 并且编写const int m_A=10;
 void test07()
 {
     extern const int m_A;
     cout<<"a = ",m_A<<endl;   //在C++中 只有当前文件才可找到，
 }

三、const分配内存

    1.对const修饰变量取地址时，会分配临时内存
    void test01()
    {
        const int m_A=10;
        int *p=(int *)&m_A;
    }
    2.const前加入extern关键字后，会分配内存
    3.使用变量来初始化const修饰的变量，会分配内存
    void test02()
    {
        int a=10;
        const int m_A=a;
        
        int *p=(int *)m_A;
        *p=20;
        cout<<m_A<<endl; //只要分配内存后，都可以间接修改成功
    }
    4.对于自定义数据类型，会分配内存
    
    struct perSon
    {
        string name;
        int age;
    }
    void test03()
    {
        const perSon p;
        perSon *p=(perSon *)&p;
        pp->name="aaa";
        pp->age=10;
        
        cout<<"name = "<<pp->name<<", age = "<<pp->age<<endl;

四、用const代替define

  #define MAX 1024; 
  
  定义的宏MAX常量从未被编译器看到过，因为在处理阶段，所有MAX 已经被替换为1024，于是MAX并没有加入到符号表中。
  
  const int max=1024;
  
  const 和 #define区别总结
        1.const有类型，可进行编译器类型安全检查，#define无类型，不可进行检查
        2.const有作用域，而#define不重视作用域，默认定义处到文件结尾，如果定义在指定作用域下有效的常量，那么#define就不能用。

C++对C的增强

一、C语言

二、C++

三、const分配内存

四、用const代替define