当前位置：首页 > news >正文

C++ 对C的扩展

news 来源：原创 2024/9/20 4:45:07

作用域运算符

符号

::

作用

1.当局部变量与全局变量重名时，区分局部变量与全局变量

变量名局部变量

::变量名全局变量

2.指明使用的变量所属的命名空间

命名空间名::变量名

3.实现函数的声明与定义分离

如:

namespace E{

void method();//函数的声明

}

void E::method02() //函数定义

{

}

如：C中代码

#include <stdio.h>

int num = 10;

int main(int argc, char const *argv[])

{

int num = 20;

printf(" 局部变量 num = %d\n",num);

// 在 c 语言中当局部变量与全局变量重名时 , 因为就近原则 , 默认使用的是局部变量

// 此时无法使用全局变量

return 0;

}

如：C++代码

#include <iostream>

using namespace std;

int num = 10;

int main(int argc, char const *argv[])

{

int num = 20;

cout << " 局部变量 num = " << num << endl;

cout << " 全局变量 num = " << ::num << endl;

return 0;

}

namespace与using

namespace

含义

命名空间

语法

namespace 空间名

{

//变量

//函数

}

注意

1.命名空间只能全局范围内定义（必须定义在函数外）

2.命名空间可嵌套命名空间

3.命名空间是开放的，即可以随时把新的成员加入已有的命名空间中

4.声明和实现可分离

5.无命名空间，意味着命名空间中的标识符只能在本文件内访问

6.命名空间别名

示例1

#include <iostream>

using namespace std;

namespace A{

int a = 1;

int b = 11;

char c = 'A';

}

namespace B{

int a = 2;

int b = 22;

char c = 'B';

}

// 命名空间可以嵌套

namespace C

{

int a = 4;

namespace D{

int a = 5;

}

}

// 命名空间是开放的，即可以随时把新的成员加入已有的命名空间中

// 不能在次定义相同的变量

namespace A{

int d = 111;

}

namespace E{

// 命名空间中可以定义函数

void method01()

{

cout << "method01" << endl;

}

// 声明和实现可分离

void method02();

}

void E::method02()

{

cout << "method02" << endl;

}

// 无名命名空间

namespace{

int a = 6;

}

int main(int argc, char const *argv[])

{

int a= 3;

cout << "A a = " << A::a << endl;

cout << "B a = " << B::a << endl;

cout << "a = " << a << endl;

cout << "C a = " << C::a << endl;

cout << "D a = " << C::D::a << endl;

cout << "A d = " << A::d << endl;

cout << " 无名 a = " << ::a <<endl;

E::method01();

E::method02();

return 0;

}

示例2

#include <iostream>

using namespace std;

namespace A{

int a = 1;

}

int main(int argc, char const *argv[])

{

// 命名空间别名

namespace A1 = A;

cout << "A a = " << A::a << endl;

cout << "A1 a = " << A1::a << endl;

return 0;

}

using

作用

声明可使得指定的标识符可用

语法

1.声明命名空间中单个变量

using 命名空间名::变量名;

2.声明命名空间中单个函数

using 命名空间名::函数名;

3.声明整个命名空间

using namespace 命名空间名;

示例

#include <iostream>

using namespace std;

namespace A{

int i = 10;

char c = 'A';

void methodA()

{

cout << "methodA" << endl;

}

}

// 声明命名空间中的单个变量

// 声明后在使用该变量就可以直接使用

using A::i;

// 声明命名空间中的单个函数

// 声明后在使用该函数就可以直接使用

using A::methodA;

// 声明整个命名空间

// 声明后整个命名空间中所以内容都可直接使用

using namespace A;

int main(int argc, char const *argv[])

{

cout << "A i = " << A::i << endl;

cout << "A i = " << i << endl;

methodA();

cout << "A c = " << c << endl;

return 0;

}

注意

using遇到函数重载，using声明就声明了这个重载函数的所有集合

重载:

同一片空间中，函数名相同，形参列表不同，成为重载

C语言不支持重载

C++支持重载

使用using声明或using编译指令会增加命名冲突的可能性

全局变量检测增强

如：C

#include <stdio.h>

int a;//c 语言编译器会认为此处为变量的声明

int a;

int a = 10;// 变量的定义与初始化

int main(int argc, char const *argv[])

{

return 0;

}

如：C++

#include <iostream>

using namespace std;

int a;//c++ 编译器将此处理解为变量的定义

//int a = 10;// 此时将会重复定义 , 程序无法编译通过

int main(int argc, char const *argv[])

{

return 0;

}

C++中所有的变量和函数都必须有类型

如：c

#include <stdio.h>

void fun(i)

{

printf("fun\n");

}

void fun02()

{

printf("fun02\n");

}

int main(int argc, char const *argv[])

{

fun(10);

fun02();

return 0;

}

如：c++

#include <iostream>

using namespace std;

//c++ 中变量必须有类型 , 此时 i 没有类型所有无法编译通过

// void fun(i)

// {

// }

// 形参中的 void 表示没有形参列表

void fun02(void)

{

cout << "fun02\n";

}

int main(int argc, char const *argv[])

{

fun02();

return 0;

}

严格的类型转换

如：c编译通过

#include <stdio.h>

#include <stdlib.h>

int main(int argc, char const *argv[])

{

int *nums = calloc(10,sizeof(int));

return 0;

}

如：c++，必须强转

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char const *argv[])

{

int *nums = (int *)calloc(10,sizeof(int));

return 0;

}

struct类型加强

c中定义结构体变量需要加上struct关键字，c++不需要

c中的结构体只能定义成员变量，不能定义成员函数。c++即可以定义成员变量，

也可以定义成员函数

示例

#include <iostream>

using namespace std;

struct Person{

char name[50];

int age;

void eat()

{

cout << name << " 吃面条 " << endl;

}

void game();

};

void Person::game()

{

cout << name << " 玩游戏 " << endl;

}

int main(int argc, char const *argv[])

{

//c 语法

struct Person p1 = {"tom",18};

//c++ 语法 , 定义结构体变量时可以不用写 struct 关键字

Person p2 = {"jek",18};

p1.eat();

p2.eat();

p1.game();

return 0;

}

新增bool类型

关键字

bool 数据类型

true 真

false 假

true（转换为整数 1）和false（转换为整数 0）

bool类型的变量取值：true或false

bool 类型赋值时，非0值会自动转换为true(1)，0值会自动转换false(0)

注意

c 语言中也有 bool 类型，在 c99 标准之前是没有 bool 关键字， c99 标准已经有

bool 类型，包含头文件 stdbool.h, 就可以使用和 c++ 一样的 bool 类型。

示例

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])

{

cout << true + 0 << endl;

cout << false + 0 << endl;

bool tag = true;

tag = false;

tag = 10;

cout << tag << endl;

return 0;

}

三目运算符功能增强

c 语言三目运算符返回的是值

c++ 三目运算符返回的是变量

如：c

#include <stdio.h>

int main(int argc, char const *argv[])

{

int a = 10;

int b = 1;

//c 语言中三目返回的是值 , 不是变量

int c = a > b ? a : b;

// 所以三目在 c 中不能作为左值 , 无法通过编译

(a > b ? a : b) = 100;

return 0;

}

如：c++

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])

{

int a = 10;

int b = 1;

//c++ 中三目返回的是变量 , 不是值

int c = a > b ? a : b;

// 所以三目在 c++ 中可以作为左值

(a > b ? a : b) = 100;

cout << "a = " << a << endl;

return 0;

}

c/c++中的const

全局变量

c

#include <stdio.h>

const int num = 10;

int main(int argc, char const *argv[])

{

//const 修饰的变量不能重新赋值

//num = 1;

// 无法进行修改 , 因为 num 的值存储在常量区

int *p = #

*p = 1;

printf("num = %d\n",num);

printf("*p = %d\n",*p);

return 0;

}

// 出现段错误

c++

#include <iostream>

using namespace std;

const int num = 10;

int main(int argc, char const *argv[])

{

//num = 1;

int *p = (int *) #

*p = 1;

cout << "num = " << num << endl;

cout << "*p = " << *p << endl;

return 0;

}

// 出现段错误

#include <iostream>

using namespace std;

struct Person

{

int age;

};

const Person p = {2};

int main(int argc, char const *argv[])

{

Person *p1 = (Person *)&p;

p1->age = 10;

cout << "p.age = " << p.age << endl;

return 0;

}

局部变量

c

#include <stdio.h>

int main(int argc, char const *argv[])

{

const int num = 10;

//const 修饰的变量不能重新赋值

//num = 1;

// 可以进行修改 , 因为 num 的值存储在栈区

int *p = #

*p = 1;

// 修改完成后 num 的值也将被修改

printf("num = %d\n",num);

printf("*p = %d\n",*p);

return 0;

}

c++

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])

{

// 在 c++ 中 const 修饰的变量会存储在常量表中

const int num = 10;

//num = 1;

// 当我们对常量表的中的变量区地址时 , 系统会开辟一片内存 , 使其存储其变量的值

int *p = (int *) #

// 此时使用指针对其修改 , 修改的是新开辟的内存中的值

*p = 1;

// 此时 num 的值依旧从常量表中获取 , 值并没有发生改变

cout << "num = " << num << endl;

cout << "*p = " << *p << endl;

return 0;

}

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])

{

int a = 10;

// 在 c++ 中 const 修饰的变量以其他变量初始化 , 会为其分配内存空间

const int num = a;

//num = 1;

int *p = (int *) #

*p = 1;

// 此时 num 的值依旧从常量表中获取 , 值发生改变

cout << "num = " << num << endl;

cout << "*p = " << *p << endl;

return 0;

}

#include <iostream>

using namespace std;

struct Person

{

int age;

};

int main(int argc, char const *argv[])

{

const Person p = {2};

//const 修饰自定义类型的变量 , 无法修改其自定义变量中的成员变量

//p.age = 10;

// 无法获取其成员变量的地址

//int *p = &(p.age);

//const 修饰的自定义类型的变量 , 无法获取其地址 , 因为地址是使用 const 数据类

型 * 修饰的

// 转换后就可以使用该指针修改其自定义类型中的成员变量

Person *p1 = (Person *)&p;

p1->age = 10;

cout << "p.age = " << p.age << endl;

return 0;

}

总结（重点）

全局变量：c/c++没区别，会出现段错误

局部变量：

1.如果const修饰的普通类型的变量，使用常量初始化

如：

const int a=10;

此时会生成符号表，当获取其变量的地址时会开辟新的地址，使用获取的地址

修改其值，不会影响符号常量表中的数据

2.如果const修饰的普通类型的变量，使用变量初始化

如：

int x=10;

const int a=x;

此时不会生成符号常量表，会直接开辟地址，获取的地址修改其值，会修改其内容

3.如果const修饰的是自定义变量

1.无法直接修改其自定义类型中的成员变量

2.无法获取自定义类型中的成员变量的地址

3.获取其自定义类型变量的地址需强转，强制过会就可以使用改地址修改其

成员变量的值

建议

尽量以 const 替换 #define

const 与 #define 的区别

1 ． const 有类型，可进行编译器类型安全检查。 #define 无类型，不可进行类型

检查 .

2 ． const 有作用域，而 #define 不重视作用域，默认定义处到文件结尾 . 如果定

义在指定作用域下有效的常量，那么 #define 就不能用

引用（重要）

英文名：reference

符号：

&

作用

给已有变量起别名

语法

基本数据类型

数据类型 &变量名A=变量B;

给变量B取别名叫变量A

此时操作A就是在操作B，操作B就是在操作A

数据类型

方式1：

typedef 数组的数据类型类型别名[数组长度]

类型别名 &别名=数组名;

方式2：

数组的数据类型（&别名）[数组长度]=数组名；

注意：此时数组长度不能忽略不写

指针

数据类型 *&别名=指针变量名;

常量

const 数据类型 &别名=变量名；

注意

1.不能返回局部变量的引用

2.函数当左值，必须返回引用。

本质

引用的本质在c++内部实现是一个指针常量

Type& ref = val; // Type* const ref = &val;

如

#include <iostream>

using namespace std;

struct Stu

{

int age;

};

// void test(Stu s)

// {

// s.age = 10;

// }

void test(Stu &s)

{

s.age = 10;

}

int main(int argc, char const *argv[])

{

Stu stu = {1};

test(stu);

cout << "stu.age = " << stu.age << endl;

return 0;

}