C++ 对C的扩展

已于 2024-08-14 09:49:24 修改
阅读量555 收藏 6
点赞数 4
文章标签： c++ 开发语言
于 2024-08-13 20:46:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52449402/article/details/141168662
版权

作用域运算符

符号

::

作用

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

内联函数

语法

inline 返回值类型 函数名 ( 形参列表 )
{
函数体
}

特点

内联函数：在编译阶段像宏一样展开。
作为类的成员函数 , 有作用域的限制
内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，
可以进行参数，返回值类型的安全检查，又可以作为成员函数。

注意

1,inline只能在定义函数的时候修饰。

2, 任何在类内部定义的函数自动成为内联函数。
3,inline 修饰的函数是否为内联函数，取决于编译器。对于非 inline 修饰的函数，也
有可能转成内联函数（体积小、功能简单的函数）。

条件

不能存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对函数进行取址操作

宏函数和内联函数区别（重要）

宏函数（带参宏）
        参数没有类型，不能保证参数的完整型。
        宏函数  在预处理阶段展开
        宏函数  没有作用域限制  不能作为类的成员
内联函数：
        参数有类型   保证参数的完整性
        内联函数  在编译阶段  展开。
        内联函数  有作用域限制  能作为类的成员

对函数的加强

形参默认值

语法

返回值类型 函数名 ( 数据类型 变量名 1 = 值 , 数据类型 变量名 2 = 值 ,...)
{
函数体
}

注意

形参中有默认值的参数，在函数调用时可传可不传，如果不传使用默认值
调用有默认值的函数，传入实参依据会按形参的顺序赋值
如果某个形参有默认值，其后的形参必须也有默认值

形参占位符

如

void test(int a,int,int)
{
}

注意

1, 形参占位符可以有多个
2, 可以在形参的任意位置

重载

函数名相同，形象列表不同，称为重载
多态的一种体现

              

                       
        
想想头疼
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
扩展卡尔曼滤波项目C++代码
03-14
本资源聚焦于"扩展卡尔曼滤波项目C++代码"，旨在为自动驾驶汽车程序提供关键的传感器融合算法。扩展卡尔曼滤波（Extended Kalman Filter, EKF）是一种在非线性系统中应用的卡尔曼滤波器，能够有效处理线性化后的系统...
vscode c/c++ 扩展
09-19
总结，"VSCode C/C++ 扩展"极大地提升了VSCode在C/C++开发中的体验，无论是语法高亮、代码补全，还是强大的调试功能，都使得VSCode成为C/C++程序员不可或缺的开发利器。只需简单安装和配置，即可享受到高效便捷的...
C++对C语言的扩充
lys20221113242的博客
03-21 1053
（1）使用命名空间::元素方式（2）使用using语句引用命名空间元素（3）使用using引用命名空间。
C++对C语言数据类型的扩展
qq_36091214的博客
12-19 1201
1.4 C++对C语言数据类型的扩展 1.4.1 结构体 1.4.2 联合 1.4.3 枚举 1.4.4 布尔 1.4.5 字符串 1.5 类型转换
c++相比C语言扩展的内容
feng_a_feng的博客
02-18 1632
1、全局变量检测增强。如果定义两个相同名称的全局变量，c语言下是不会报错的，c++下会报错。 2、类型的扩展，c++有bool类型，c语言下没有。 3、struct结构体的增强，c++下可以存放函数，c语言下不可以。 4、函数检测增强，c++下 函数的参数必须要填写变量的类型，c语言则没有这样严格，可写或不写。 5、三目运算符的增强,c++下放回的是变量，可以再对返回的变量赋值；而c语言下返回的是...
C++对C的扩展
qq_38960965的博客
05-17 294
C语言和C++语言关系 C++是C语言的加强，是一种更好的C语言 C++是以C语言为基础的，并且完全兼容C语言的特性 C语言 + 面向对象方法论===》Objective C /C++ C++：以C语言为基础+面向对象支持+（类型加强、函数加强、异常处理） 命名空间：namespace 标准格式： namespace name{.....} C中的命名空间 ...
使用c/c++扩展Python
WR0309的博客
02-07 1736
使用python做开发的时候，如果有些业务对性能有要求，可以考虑使用c/c++来实现Python的模块，例如游戏开发中，可以使用Python完成一些玩法逻辑，但是技能结算等这些高密度计算部分如果放在python实现，那么性能不是很理想，这个时候可以把这部分弄到c/c++中来实现。
VSCode的C/C++扩展功能
热门推荐
泠山的博客
02-21 1万+
VSCode的C/C++扩展功能1. 在 Linux 上 使用 C++1.1 创建 Hello World1.2 探索 IntelliSense1.3 构造 helloworld.cpp1.3.1 运行 build1.3.2 修改 tasks.json二级目录三级目录 Reference: Visual Studio Code的C/C++扩展功能 Using C++ on Linux in VS Code 1. 在 Linux 上 使用 C++ 1.1 创建 Hello World 从 termina
C++学习Day01之C++对C语言增强和扩展
似霰的博客
02-02 946
C++之C++对C语言增强和扩展
使用C++编写Python扩展
To learn, to engage.
03-29 3875
使用扩展的方式调用 C++ 函数，更容易防止两种程序空间使用出现冲突。
c++中对函数的扩展
qq_40508591的博客
08-21 525
c++对函数的扩展 1、inline内联函数 将函数体中的代码内嵌入函数调用的地方，不再发生函数调用----------内存空间换取运行时 间的操作。 （编译时间换取内存空间：宏函数 内存空间换取运行时间：inline函数） 1）C++对内联函数的扩展： C语言只要声明inline，一定会以内联的方式进行处理； C++请求编译器将该函数内联！（会进行判断，可以拒绝请求）。 2）什么时候使用内联函数？ 功能简单且代码短小，调用频繁。 3）使用注意事项： 调用内联函数之前必须声明或者定义该
VS CODE离线安装C/C++扩展包
06-25
VS CODE离线安装C/C++扩展包，具体安装方法可参考我的博客。
PyTorch中的C++扩展实现
12-20
在PyTorch中，C++扩展允许开发人员利用C++的高效性能和灵活性来创建自定义的神经网络层和操作，以实现更复杂的计算或优化性能。以下将详细阐述PyTorch C++扩展的实现过程及其重要性。 首先，我们要明白为什么要使用...
vs cose c/c++扩展安装包
04-06
**Visual Studio Code C/C++ 扩展安装指南** 在编程领域，C++ 是一种广泛使用的系统级和应用级编程语言，而Visual Studio Code (VS Code) 是微软开发的一款轻量级但功能强大的源代码编辑器。为了在VS Code中编写和...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 705
内存管理
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 375
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 487
c++ error: ‘*’ does not name a type； did you mean ‘**’?
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1192
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 845
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值