C++对C语言的增强总结

C++对C语言的增强

全局变量检测增强

c语言示例

int a;
int a = 10; //C下可以，C++重定义

函数检测增强

c语言示例

//函数检测增强  返回值没有检测  形参类型没有检测   函数调用参数个数没有检测,可以正常调用
getRectS( w  , h)
{
    return w *h;
}
void test()
{
    printf("%d\n", getRectS(10, 10, 10));
}

而在C++中会对函数的返回值、形参类型、函数调用参数个数进行检测，以上代码不能生成

类型转换检测增强

c语言示例

//开辟一个64字节的空间
char * p = malloc(64);

c++等号左右类型必须一致char * p = (char *)malloc(64)需要进行强制类型转换

struct 增强

1. C语言下 结构体不可以有函数

2. 创建结构体变量时候，必须加关键字struct

   //C代码
   struct Person
   {
    int age;
    //void func(); C语言下 结构体不可以有函数
   };
   void test()
   {
    struct Person p; //创建结构体变量时候，必须加关键字struct
    p.age = 100;
   }

3. C++可以放函数

4. 创建结构体变量，可以简化关键字 struct

   struct Person
   {
    int age;
    void func()
    {
        age++;
    }
   };
   

void test()
{
Person p;
p.age = 17;
p.func();
cout << “p的age = “ << p.age << endl;
}

### bool数据类型扩展
1. C++有bool类型，C没有bool类型
2. bool类型代表 真和假true代表真，实际值为1;false为假，实际值为 0
3. sizeof = 1占用一个字节
4. 将非0的数都转为1
```c
bool flag = true; 
void test()
{
    cout << sizeof(bool) << endl; //结果是1个字节
    //flag = false;
    //flag = 100; //将非0的数都转为1
    cout << flag << endl;
}

三目运算符增强

1. C语言下返回的是值

2. C++语言下返回的是变量

   void test()
   {
    int a = 10;
    int b = 20;
   
    printf("ret = %d\n", a > b ? a : b); //20
   
    (a > b ? a : b )= 100; // C++下返回的是变量,所以允许 b = 100，C语言中返回的是值20 = 100不允许
   
    printf("a = %d\n", a);
    printf("b = %d\n", b);
   }

const增强

C语言下

在C语言下 const是伪常量，不可以初始化数组，不能进行如下操作

const int M_A = 100;//常量区
int a[M_A];

全局const

1. 直接修改失败
2. 间接修改,语法通过，受到常量区的保护，运行失败

   #include <stdio.h>
   const int M_A = 100;//常量区
   void test() {
    //M_A = 200; 直接修改失败
    int* p = &M_A;
    *p = 20;
   }
   int main() {
    test();
   }

局部 const

1. 直接修改失败

2. 间接修改成功

   void test() {
    //局部const，声明在栈中，为伪常量
    const int m_B = 100; //分配到栈上
    //m_B = 200;
    int* p = &m_B;
    *p = 200;
   
    printf("%d\n", m_B);//200
   }

C++语言下

C++ const可以称为常量,任何状态下都不能修改

const int m_A = 100;
void test06()
{
    //m_A = 200; 失败
    //int * p = (int *)&m_A;//需要强制转换
    //*p = 200;

    const int m_B = 100;
    //m_B = 200;
    int * p = (int *)&m_B;
    *p = 200;
    cout << "m_B = " << m_B << endl;

    int arr[m_B]; //C++下const修饰的变量 称为常量 ，可以初始化数组

}

全局 const 和C结论一样

1. 直接修改失败
2. 间接修改,语法通过，受到常量区的保护，运行失败

局部 const

1. 直接修改失败
2. 间接修改 失败 （程序正常运行但变量没有修改）
   

const 链接属性

C语言下const修饰的全局变量默认是外部链接属性

const.c

const int g_a = 1000;

const_test.c

#include<stdio.h>

int main(){
    //声明变量，即可以使用，找不到时会在链接阶段报错
    extern const int g_a; 
    printf("g_a = %d\n", g_a);    
    return 0;
}

C++下const修饰的全局变量默认是内部链接属性，可以加extern 提高作用域

const.cpp

const int g_a = 1000;//只能本文件使用
extern const int g_b = 1000;//默认是内部链接属性 可以加关键字 extern 提高作用域

const_test.cpp

#include<iostream>
using namespace std;
int main(){
    extern const int g_b;
    cout << "g_b = " << g_b << endl;
    return 0;
}

const分配内存情况(C++)

#include<iostream>
using namespace std;
#include <string>

//1、对const变量 取地址 ，会分配临时内存  
// 1.1 int temp = a;
// 1.2 int *p = (int *) temp;
void test01()
{
    const int a = 10;
    int * p = (int *)&a;
}

//2、使用普通变量  初始化 const变量,会分配内存，分配内存后，可以通过(间接方式)指针修改其内容
void test02()
{
    int a = 10;
//    const int b = 10; //此时不能修改其内容
    const int b = a; //使用变量进行初始化b时会在栈上分配内存，可以通过间接引用修改其内容 

    int *p = (int *)&b;
    *p = 1000;

    cout << "b = " << b << endl; // 1000
}

//3、对于自定义数据类型 
struct Person
{
    string m_Name;
    int m_Age;
};
void test03()
{
    const Person p;
    //p.m_Age = 10; //不能直接修改

    //可以间接修改
    Person * pp = (Person *)&p;
    //解引用方式修改内容
    (*pp).m_Name = "Tom";
    //指针箭头方式修改内容
    pp -> m_Age = 10;

    cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}

1. 对const变量 取地址 ，会分配临时内存
2. 使用普通变量 初始化 const变量
3. 对于自定义数据类型，会分配内存

尽量用const代替define

1. define定义的宏常量，没有数据类型、不重视作用域，需使用undef进行卸载
2. const有类型，可以进行类型安全检查
3. const有作用域，define没有作用域默认定义处到文件结尾有效。