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;
}

1. C++可以放函数
2. 创建结构体变量，可以简化关键字 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

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没有作用域默认定义处到文件结尾有效。