【C++】01.从C语言转向C++

卡戎-caryon

已于 2024-05-11 20:55:30 修改

阅读量1.2k

点赞数 19

分类专栏： C++ 文章标签： c++ 笔记

于 2024-04-11 20:07:49 首次发布

本文链接：https://blog.csdn.net/2301_80258336/article/details/137649192

版权

C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

一.对C++的认识

首先让我们认识一下祖师爷： 本贾尼·斯特劳斯特卢普

接下来我们就需要了解为什么会有C++语言。

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。

1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C 语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。

1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

了解了C++的历史，接下来我们就来进入正文了。

二.C++的关键字

C++完全可以兼容C语言，因此，C语言的关键字也是C++的关键字，而且C++对此作了拓展，C++共有63个关键字，会在后续的学习中逐步接触到。

三.命名空间

由于在大型项目的编程中，存在着多个人同时使用了同一变量名的情况，若修改变量名，则会破坏程序的可读性，因此，祖师爷应用了命名空间来解决这个问题。

3.1命名空间的定义

使用namespce关键字来定义命名空间，如下：

namespace A
{
    int A;
    void Init();
    //可以定义变量/函数/类型，也可以嵌套
    namespace B
    {
        int B;
    }
}

在上述代码中我们看到了命名空间是可以嵌套定义的。

在一个工程中允许存在着多个名称相同的命名空间，编译器会将其自动合并。

3.2命名空间的使用

当展开命名空间时，在编译器的默认搜索中，先从局部搜索，然后在全局和命名空间内搜索。

命名空间共有三种使用方式：

1) 加命名空间名称以及作用域限定符

2）使用using将命名空间内的某个成员引入

3）使用using namespace 命名空间名称引入

1) A::a;
2)using A::a；//指定展开某一个变量
3)using namespace A;//展开整个命名空间

四.C++的输入与输出

和C语言一样，C++的输入和输出也需要包含头文件，C++的头文件为<iostream>

输入： cout <<流插入运算符

输出： cin >>流提取运算符

cin和cout是分别是istream和ostream类型的对象，后续会有一个章节对此进行专门讲解。

C++和C不同的是，C++可以自动识别变量类型。

关于std命名空间的使用：

1.日常练习中，建议直接使用using namespace std；即可

2.项目开发中，直接展开可能会造成命名冲突，建议使用形如 std::cout 这种格式，或指定展开如 using std::cout；

五.缺省参数

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

5.1全缺省参数

例如：void Func(int a=20,int b=30,int c=40);

5.2半缺省参数

例如：void Func(int a,int b,int c=10);

注意：

1.半缺省参数必须从右向左依次给出，不能间隔着给

2.缺省参数不能在声明和定义同时出现

3.缺省值必须是常量或全局变量

4.C语言并不支持

六.函数重载（非常重要）

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

#include<iostream>
using namespace std;
// 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;
}

int main()
{
     Add(10, 20);
     Add(10.1, 20.2);
     f();
     f(10);
     f(10, 'a');
     f('a', 10);
     return 0;
}

问题：为什么C语言不支持函数重载，而C++支持函数重载？

回答：在编译阶段，源文件经过预编译，编译，汇编生成.obj文件，在此过程中C语言不对函数名进行任何处理，而C++则对函数名进行修饰。接下来，源文件需要与头文件进行链接生成可执行程序。在C语言中，源文件与头文件链接时是直接通过函数名去检索，而C++是使用修饰后的函数名去检索，从而使得C++支持函数重载，而C语言不支持。

七.引用

从某种意义上来说，引用就是给给已经存在的变量取了个别名。编译器并不会为它开辟一块新的空间。应用：

void swap(int* a,int* b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}

void swap(int& a,int& b)
{
    int temp=a;
    a=b;
    b=temp;
}

int main()
{
    int a=1,b=0;
    swap(&a,&b);//指针
    swap(a,b);//引用
    return 0;
}

7.1引用的特性

引用在定义时必须初始化。

一个变量可以有多个引用，而一个引用只能对应一个变量。

引用的效率比传值调用要高，因为传值调用需要为新变量开辟空间。

7.2常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量，该语句对a进行了权限的放大
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，10为常量，b对10进行了权限的放大
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;//生成了中间变量，中间变量具有常性
}

使用场景：

做参数：

void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}

做返回值：

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

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

7.3引用和指针的区别

语法上：引用是取别名，没有独立空间。

底层实现上：引用是按指针方式实现的。

接下来看下引用和指针的汇编代码比较：

不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终不变。（看多少位机）

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

10.引用比指针的效率更高

八.内联函数（关键字inline）

内联函数和普通函数对比可以看到：内联函数不需要call函数，而是直接展开，没有函数调用建立栈帧的开销，提升了程序的运行效率

1）inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

2）inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

2）inline不支持声明定义分离，分离会导致链接错误，因为inline被展开没有函数地址，无法链接。

九.auto关键字（C++11）

9.1auto的引入

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

1. 类型难于拼写

2. 含义不明确导致容易出错

可能有人想到使用typedef给类型取别名，但是在有些编译时可能会存在问题：

typedef char* pstring;
int main()
{
     const pstring p1;    // 编译成功还是失败？
     const pstring* p2;   // 编译成功还是失败？
     return 0;
}

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

9.2 auto简介

早期使用auto修饰表示是具有自动存储器的局部变量（自动销毁）。C++11中，auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int TestAuto()
{
     return 10;
}

int main()
{
     int a = 10;
     auto b = a;
     auto c = 'a';
     auto d = TestAuto();
 
     cout << typeid(b).name() << endl;
     cout << typeid(c).name() << endl;
     cout << typeid(d).name() << endl;
 
     //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
     return 0;
}

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

9.3auto的使用细则

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

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

auto*声明是一个指针变量

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

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

9.4不能推导的场景

1）auto不能作为函数参数

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

}

2）auto不能直接用来声明数组

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

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有 lambda表达式等进行配合使用。

十.范围for循环（C++11）

10.1范围for的语法

在C++98中遍历数组可以使用如下方式。

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
     array[i] *= 2;
 
 for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
     cout << *p << endl;
}

而在C++11中提供了另一种遍历方式。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)
     e *= 2;
 
 for(auto e : array)
     cout << e << " ";
 
 return 0;
}

10.2范围for的使用条件

1）for循环迭代的范围必须是确定的。对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。

2）迭代的对象要实现++和==的操作。

十一.nullptr关键字（C++11）

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

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

NULL实际是一个宏，在传统的C头文件(stddef.h)中，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

void f(int)
{
     cout<<"f(int)"<<endl;
}
void f(int*)
{
     cout<<"f(int*)"<<endl;
}
int main()
{
     f(0);
     f(NULL);
     f((int*)NULL);
     return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

注意：

1）在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

2）在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

3）为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

卡戎-caryon

关注

19
点赞
踩
24

收藏

觉得还不错? 一键收藏
5
评论
【C++】01.从C语言转向C++

使用namespce关键字来定义命名空间，如下：int A;//可以定义变量/函数/类型，也可以嵌套int B;在上述代码中我们看到了命名空间是可以嵌套定义的。在一个工程中允许存在着多个名称相同的命名空间，编译器会将其自动合并。
复制链接

扫一扫

专栏目录