C++对C增强部分

全局变量检测增强
int a;
int a = 10;
C++ 不可以，C可以

函数检测增强
函数参数类型增强，C++ 必须有参数类型
函数返回值检测增强，C++ 必须有返回值类型
函数参数传入增强，C++ 传入参数数量不能大于已定义数量

int getRectS(a, b) {
}    

getRectS() {
}

int getRectS(int w, int h) {
}

getRectS(1, 2, 3)

类型转换增强
void * 万能指针，C++不支持，需要强制类型转换

// c
char * p = malloc(sizeof(64));//malloc返回值时void*
// c++
char * p = (char *)malloc(sizeof(64));//malloc返回值时void*

struct增强

• C++ 中struct可以加函数, C不可以
• C++ 中使用struct，可以不加struct关键字

struct Person {
    int m_Age;
    void plusAge();//C语言中struct不可以加函数
}
Person p1;

bool类型增强
C++ 中有bool类型，C没有
C++ 中bool类型只有true或false；C中数字表示，只有非0或者0
C++ 中bool类型，赋值大于1时，自动为1
C++ 中bool类型，长度一直是1

bool b = 100;
std::cout << "bool :" << b << std::endl;
std::cout << "sizeof :" << sizeof(b) << std::endl;

三目运算符增强
C++ 中运算结果返回时是变量不是值; C返回的是值
C++中=优先级比? :高，(a > b ? a : b) = 100与a > b ? a : b= 100逻辑是不一样的
(a > b ? a : b) = 100：a大于b，返回a后对其赋值100；a小于b，返回b后对其赋值100；
a > b ? a : b= 100：a大于b，返回a；a小于b，返回b后对其赋值100；

int a = 20;
int b = 10;
std::cout << "三目运算结果：" << (a > b ? a : b) << std::endl;
//根据三目运算结果 a = 100;
std::cout << "三目运算结果：" << ((a > b ? a : b) = 100) << std::endl;
std::cout << "三目运算 a：" << a << "   b："<< b << std::endl;
//根据三目运算结果 a = 100;
std::cout << "三目运算结果：" << (a > b ? a : b = 1000) << std::endl;
std::cout << "三目运算 a：" << a << "   b：" << b << std::endl;
b = 300;
std::cout << "三目运算结果：" << (a > b ? a : b = 1000) << std::endl;
std::cout << "三目运算 a：" << a << "   b：" << b << std::endl;

// C中模仿C++
printf("ret = %d \n", a>b?a:b);  //C语言编译器正常
// a > b ? a : b = 100; C语言编译器报错
*(a > b ? &a : &b) = 100;   //C语言编译器正常

const增强
C++中默认const是内部链接，只能当前文件访问；前面加extern就变成外部链接
C中默认const是外部链接
** C++中 const修饰后不分配内存，放在符号表中，可以用来初始化数组**
C中伪常量会分配内存，所有分配内存的都可以绕过编译器修改
C++中会分配内存的几种情况：（只要分配内存就能修改，临时内存修和extern无法修改）

• 取地址会分配临时内存，只能修改临时内存

     const * m_A = 10;//放在符号表，无法修改
  int * p = (int*)m_A;//分配临时内存
  

• extern修饰时编译器也会给const变量分配内存

     const * m_A = 10;//放在符号表，无法修改
  int * p = (int*)m_A;//分配临时内存
  

• 用普通变量初始化 const的变量

  int a = 10;
  const int b = a;//会分配内存
  

• 自定义数据类型 加const也会分配内存

  struct Person
  {
      string m_Name;
      int m_Age;
  }
  
  void test03(){
      Const Person p1;
          //P1.m_Name = "aaaa";//编译器不允许修改
      Person * p = (Person*)&p1;
      p->m_Name = "德玛西亚";
      (*p).m_Age = 18;
  
      cout << "姓名：" << p1.m_Name<< "年龄：" << p1.m_Age << endl;
  }
  

• 尽量以const替换#define
  我们定义的宏PARAM 从未被编译器看到过，因为在预处理阶段，所有的PARAM以及被替换为了1024，于是PARAM并没有将其加入到符号表中，但我们使用这个常量获得一个编译错误信息时，可能会带来一些困惑，因为这个信息可能会提到1024，但是没有提到PARAM,如果PARAM被定义在一个不是你写的头文件中，你可能并不知道1024代表什么，也许解决这个问题会花费很长时间。
  解决办法：就是用一个常量替换上面的宏。
  const int PARAM = 2014；
  const 和 #define区别总结：
      const 有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查
      const有作用域，而#define不重视作用域，默认定义处到文件尾，如果定义在指定作用域下有效的常量，那么#define就不能用。
  1. 宏常量没有类型，所以调用了int类型重载的函数。const有类型，所以调用希望的short类型函数？

  #define PARAM 128
  const short param = 128;
  void func(short a) {   
     cout << "short!" << endl;
  } 
  void func(int a) {
      cout << "int" <<endl;
  }
  

  2. 宏常量不重视作用域

  void func1() {
     const int a = 10;
     //定义宏常量A
     #define A 20;
     //卸载宏常量A,结束声明周期
     //#undef A
  }
  void func2(){ 
     //#define 作用域从定义到文件结束或者到#undef,可访问
     //cout << "a:" << A << endl;
  }
  int main(){
     fun2();
     return EXIT_SUCCESS;
  }