C++入门

xiaoyi132

于 2024-07-04 01:34:20 发布

阅读量607

点赞数 25

文章标签： c++

本文链接：https://blog.csdn.net/xiaoyi132/article/details/140164144

版权

C++是一门面向对象编程语言,与C语言相比增加许多有用的库,以及编程范式

5.1.C++支持函数重载的原理 -- 名字修饰

C++是一门面向对象编程语言,与C语言相比增加许多有用的库,以及编程范式

1.C++关键字(C++98)

C++总计63个关键字,C语言有32个关键字

如图C++关键字

2.命名空间

在C/C++中,变量,函数,和类都是大量存在的,若这些全在一给作用域,其中难免会有许多命名冲突,

因此需要使用命名空间对标识符的名称进行本地化，以避免命名冲突或名字污染

2.1.命名空间定义

使用命名空间需要关键字namespace,后面跟命名空间的名字,然后接一对{}即可,

其中需要注意

命名空间支持嵌套,可在命名空间中定义变量/函数/类

在同一工程中若出现相同名称命名空间,则在编译器处理后会合成为同一个命名空间

而命名空间相当于定义一个新的作用域,命名空间所有内容都局限于该命名空间

2.2.命名空间使用

命名空间中的成员该如何使用,如下:

namespace lixixi
{
 // 命名空间中可以定义变量/函数/类型
    int a = 0;
    int b = 1;

    int Add(int left, int right)
    {
        return left + right;
    }

    struct Node
    {
        struct Node* next;
        int val;
    };
}

int main()
{
    // 编译报错：error C2065: “a”: 未声明的标识符
    printf("%d\n", a);    
    return 0;
}

使用命名空间中的变量我们需要事先声明方可使用

而声明有三种不同方式:

命名空间名称加作用域限定符(::)

printf("%d\n", lixixi::a);

使用using关键字将命名空间中某个成员引入

using lixixi::b;

使用using namespace + 命名空间名称引入

using namespace lixixi;

第一种声明变量作用域局限当前一行,而后续两种方式则为全局

3.C++ 输入 & 输出

C++在支持原来C格式化输入/输出的基础上,使用标准输入cin(键盘)/标准输出对象cout(控制台)实现输入/输出功能

在使用上述对象时,必须包含<iostream>头文件以及引入命名空间std(std是C++标准库的命名空间名,C++将标准库的定义实现都放到这个命名空间中)

#include<iostream> 
using namespace std;    //引入C++标准库
int main()
{
    int a = 10;
    double b = 7.1;
    char c = "A"
    cout << "Hello World!" << endl;
    cout << a << " " << b << " " << c << endl;
//输出:Hello World
//     10 7.1 A
        
    return 0;
}

从上述代码需要说明

cout 与 cin 是全局的流对象,endl是特殊C++符号,表示换行输出,相当于"\n",他们都包含在头文件<iostream>中
<< 是流插入运算符, >> 是流提取运算符
使用C++输入输出更方便,不需要像printf/scanf输入输出那样,需要手动控制格式,C++的输入输出可以自动识别变量类型

我们会发现在引入头文件<iostream>是并没有像C添加后缀.h,

那是因为早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式。

4.缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值,在调用该函数时,如果没有指定实参,则采用该形参的缺省值

1.缺省参数的分类

全缺省参数

void func(int a = 10, int b = 20)
{
    cout << a << " " << b << endl;
}

int main()
{
    func();    // 10 20
    func(20,30); // 20 30
}

半缺省参数

void Func(int a, int b = 10, int c = 20)
 {
     cout << a << endl;
     cout << b << endl;
     cout << c << endl;
 }

注意:

半全省参数必须从右往左依次给出,不能间隔着给
缺省参数不能在函数声明和定义中同时出现(若声明与定义同时提供不同的值的缺省参数,编译器会无法确定使用哪个缺省值)
缺省值必须时常量或者全局变量

5.函数重载

函数重载:函数的一种特殊情况,C++允许同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 / 类型 / 类型顺序)不同,常常用来处理 功能类似,数据类型不同 的问题

1.参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
     cout << "double Add(double left, double right)" << endl;
     return left + right;
}

2.参数个数不同
void f()
{
    cout << "f()" << endl;
}

void f(int a)
{
    cout << "f(int a)" << endl;
}

3.参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

5.1.C++支持函数重载的原理 -- 名字修饰

在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预处理,编译,汇编,链接

如图

实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们可以知道，(当前a.cpp中调用了b.cpp中定义的Add函数时) 编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
所以链接阶段就是专门处理这种问题,链接器看到a.o调用Add,但是没有Add的地址,就会到b.o的符号表中找Add的地址,然后链接到一起。
那么链接时,面对多个Add函数,链接器会对不同的参数列表的同名函数进行函数名修饰,这里每个编译器都有自己的函数名修饰规则

而C语言无法支持函数重载的原因就在于,面对多给同名函数 C编译器无法对其进行函数名修饰,

而C++通过函数名修饰原则,只要参数不同,修饰出来的名字就不同,(需要注意如果两个函数的函数名和参数列表相同而返回值不同是无法构成重载的,因为调用时编译器无法区分,即修饰后名字相同)

6.引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

使用方法: 类型& 应用变量名(对象名) = 应用实体

int a = 10; int& ra = a; //ra 即整型 a 的别名

注意 : 引用类型必须和引用实体是同种类型

6.1 引用特性

引用在定义时必须初始化
一个变量可有多个引用
引用一旦引用一个实体,在不能引用其他实体

6.2 常引用

对于常量的引用,我们需要使用关键字const来对其进行引用

void TestConstRef()
{
    const int a =  10;
    //int& ra = a; //该语句编译时会出错,a为常量
    //正确引用如下
    const int& ra = a;

    //int& b = 10; //编译出错
    //正确如下
    const int& b = 10;
}

6.3 使用场景

做函数参数

避免在后续类的拷贝构造中避免死循环,同时可节省一定空间

做返回值

可节省一次返回值参数的拷贝

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

6.4 传值,传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接 传递实参 或者将变量本身直接返回，而是 传递实参 或者 返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

6.5 引用与指针的区别

在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间

但通过调试后汇编代码对比,我们会发现在底层实现上实际是有空间的,且引用是按照指针方式来实现的

引用和指针的不同点:

引用概念上定义一个变量的别名,指针存储一个变量地址
引用在定义时必须初始化,指针没有要求
引用在初始化时引用一个实体后,就不能再引用其他实体,而指针若没有const修饰则可以在任何时候指向任何一个同类型实体
没有NULL引用,但存在NULL指针
在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台占4byte,64位占8byte
引用+1即引用实体增加1,指针+1即指针向后偏移一个类型大小
有多级指针,但没有多级引用
访问实体方式不同,指针需要显示解引用,引用由编译器自行处理
引用比指针使用相对安全(没有野指针的存在)

7.内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

7.1 特性

inline是一种以空间换时间的做法,如果编译器将函数当成内联函数处理,在编译过程,会用函数体替换函数调用(不会建立相应函数栈帧),缺陷: 可能使目标文件变大,优势:少了调用开销,提高程序运行效率
inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同,一般建议:将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现),不是递归,且频繁调用的函数采用inline修饰,否则编译器会忽略inline特性(内联说明只是向编译器发出一个请求,编译器可以选择忽略这个请求)
内联机制用于优化规模较小,流程直接,频繁调用的函数,大多数编译器不支持内联递归
inline不建议声明和定义分离,分离会导致链接错误,因为inline被展开,就没有函数地址,即使编译时生成符号表,在链接时也会找不到相应函数地址

此时发现宏作用与内联相似

宏的优点在于

增强代码复用性
提高性能

缺点在于

不方便调试宏,在预编译阶段就对其进行替换
导致代码可读性较差,可维护性差,容易误用
没有类型安全的检查

C++有哪些技术替代宏

常量定义换用const enum
短小函数定义换用内联函数

8.auto关键字(C++11)

随着程序越来越复杂,程序中用到的类型也越来越复杂,经常体现在:

类型难于拼写
含义不明确导致容易出错

例如当我们定义map的迭代器时需要

std::map<std::string,std::string>::iterator it = mp.begin()

此时可以使用typedef对其迭代器类型取别名,但typedef并非简单的字符替换

例如

typedef char* pstring;
int main()
{
    const char* p1;    //p1类型为const char*
    const pstring p2;    //p2类型为char* const   
    return 0;
}

原因在于const给予了整个指针本身以常量性,也就是形成了常量指针char* const。
简单来说,记住当const和typedef一起出现时,typedef不会是简单的字符串替换就行。

8.1.auto简介

在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,但遗憾的是一直没有人去使用它

C++11中，标准委员会赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得

【注意】使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

8.2.auto的使用细则

1.auto与指针和引用结合起来使用

用auto声明指针类型时,用auto和auto*没有区别,但用auto声明引用类型时必须加&

2.在同一行定义多个变量

当在同一行声明多个变量时,这些变量必须是相同类型,否则编译器将会报错,因为编译器实际只对第一个类型进行推导,用推导出来类型定义其他变量(与C语言类似)

8.3.auto不能推导的场景

auto不能作为函数参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

auto不能直接用来声明数组

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4,5,6};//报错
}

避免与C++98中的auto进行混淆,C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法即使用迭代器C++11提供的新型for循环,还有lambda表达式等进行使用

9.指针空值nullptr(C++11)

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
    // ……
}

NULL实际上是一个宏,在传统C头文件(stdio.h)中可以看到如下代码:

可以看到,NULL可能定义为字面常量0,也可能被定义为无类型指针(void*)的常量,无论采用哪种定义,在使用空值指针时,都不可避免的会遇到些麻烦,比如:

void f(int)
{
    cout << "f(int)" << endl;
}

void f(int*)
{
    cout << "f(int*)" << endl;
}

int main()
{
    f(0);    //f(int)
    f(NULL);    //f(int)
    f((int*)NULL);    //f(int*)
    return 0;
}

可以看到

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

注意:

在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++11作为新关键字引入的.
在C++11中,sizeof(nullptr)与sizeof((void*)0)所占字节相同
本博客仅个人总结用

xiaoyi132

关注

25
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
C++入门

在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,但遗憾的是一直没有人去使用它C++11中，标准委员会赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得【注意】使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。
复制链接

扫一扫