C++对C增强部分

作者: ArcherZang | 来源:发表于2019-05-30 16:39 被阅读0次

C++对C增强部分
从c到c++快速入门2019
2023-02-08
[初学C++]C++基于C增强
c和c++比较
c++学习文档-更新于2020年12月05日
（Boolan） Week1
C++基本概念复习_2018-06-25
C++面试题整理
学习笔记 | C++ 标准模板库（Standard Templa

全局变量检测增强
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;
}
```
  1. 宏常量不重视作用域
```
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;
}
```