C++入门

最新推荐文章于 2024-07-09 22:37:42 发布
最新推荐文章于 2024-07-09 22:37:42 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcsq0523/article/details/123674183
版权

C++入门

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

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

**ps：**下面只是看一下C++有多少关键字，不对关键字进行具体的讲解。

asmdoifreturntrycontinue
autodoubleinlineshorttypedeffor
booldynamic_castintsignedtypeidpublic
breakelselongsizeoftypenamethrow
caseenummutablestaticunionwchar_t
catchexplicitnamespacestatic_castunsigneddefault
charexportnewstructusingfriend
classexternoperatorswitchvirtualregister
constfalseprivatetemplatevoidtrue
const_castfloatprotectedthisvolatilewhile
deletegotoreinterpret_cast

2. 命名空间

命名冲突问题：（C语言没有很好地解决这个问题）

1、自定义变量、函数与库里的重名冲突

2、团队合作后，与其他人的代码命名冲突

image-20211123234702009

#include <stdio.h>
#include <stdlib.h>

// 定义1个叫bit的命名空间 - 域
// 命名空间中可以定义变量/函数/类型
namespace bit
{
    // 命名空间属于全局变量，放在静态区
    int rand = 0;
    
    int Add(int left, int right)
    {
        return left+right;
    }
    
    struct Node
    {
    	struct Node* next;
    	int val;	
    };
}

int main()
{
    printf("hello world\n");
    printf("%d\n", rand);// 局部 -> 全局 - 若全局也找不到变量，则error
    printf("%d\n", bit::rand);// 到命名空间内寻找变量
	
    // 命名空间的使用
    bit::rand = 10;
    struct bit::Node node;
    bit::Add(1,2);
    
    return 0;
}
  • 命名空间起“隔离”的作用，影响编译器查找的规则
  • 命名空间中可以定义变量/函数/类型
  • 命名空间属于全局变量，放在静态区

2.1 命名空间的定义

命名空间规定了寻找的路径

//1. 普通的命名空间
namespace ly // ly为命名空间的名称
{
    // 命名空间中的内容，既可以定义变量，也可以定义函数
    int a;
    int Add(int left, int right)
    {
        return left + right;
    }
}

int main()
{
    ly::a = 10;
    ly::Add(1, 2);

    return 0;
}

//2. 命名空间可以嵌套
namespace N2
{
    int a;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }

    namespace N3
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
            return left - right;
        }
    }
}

int main()
{
    N2::Add(1, 2);
    N2::N3::Sub(1, 2);

    return 0;
}

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合并到同一个命名空间中。
// "List.h"
namespace ly
{
    struct ListNode
    {
        // ...
    };

    void ListInit();
    void ListPushBack(struct ListNode* phead, int x);
}

// "List.c"
#include "List.h"
namespace ly
{
    void ListInit()
    {
        // ...
    }

    void ListPushBack(struct ListNode* phead, int x)
    {
        // ...
    }
}

// "test.c"
#include "List.h"
int main()
{
	struct ly::ListNode ln;
	ly::ListInit();

	return 0;
}

2.2 命名空间使用

命名空间中成员该如何使用呢？

namespace N
{
     int a = 10;
     int b = 20;
     int Add(int left, int right)
     {
     return left + right;
     }
     int Sub(int left, int right)
     {
     return left - right;
     }
}
  • 加命名空间名称及作用域限定符（很好地做到命名隔离，但是使用繁琐，每次使用都要展开）
int main()
{
     printf("%d\n", N::a);
     return 0; 
}
  • 使用using将命名空间中某个成员引入（用于展开命名空间中常用的）
using N::b;
int main()
{
     printf("%d\n", N::a);
     printf("%d\n", b);
     return 0; 
}
  • 使用using namespace将命名空间中所有成员引入（全部展开到全局，使用方便，但隔离便失效了，慎用）
using namespce N;
int main()
{
     printf("%d\n", N::a);
     printf("%d\n", b);
     Add(10, 20);
     return 0; 
}

3. C++输入&输出

C++库的实现定义在一个叫std的命名空间中

#include <iostream> 
//using namespace std; // 指定命名空间，但此写法不好，全部展开则命名空间失效
// 推荐：将常用的展开
using std::cout;
using std::endl;

int main()
{
    cout << "hello world" << endl;
    return 0;
}

#include <iostream>
using namespace std;// C++库的实现定义在一个叫std的命名空间中

int main()
{
    // << 流插入运算符
    cout << "hello world" << endl;// 理解："hello world"和换行(endl)流向cout
    cout << "hello world\n" ;// 以下等价
    printf("hello world\n");

    int i = 10;
    double d = 1.11;
    // cout可以自动识别类型
    cout << i << " " << d << endl;
    
    // >> 流提取
    cin >> i >> d;// 输入到i，d
    cout << i << " " << d << endl;// 输出
    return 0;
}

#include <iostream>
using namespace std;

struct Student
{
    char name[20];
    int age;
    // ...
};

int main()
{
    struct Student s = { "鹏哥",18 };
    // << 流插入运算符
    // cpp写法示例
    cout << "姓名:" << s.name << endl;
    cout << "年龄:" << s.age << endl << endl;
    
    // c写法示例
    printf("姓名:%s\n年龄:%d\n", s.name, s.age);

    // 流提取运算符
    cin >> s.name >> s.age;
    cout << "姓名:" << s.name << endl;
    cout << "年龄:" << s.age << endl << endl;

    scanf("%s%d", s.name, &s.age);
    printf("姓名:%s\n年龄:%d\n", s.name, s.age);
    return 0;
}

说明：

  1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含**< iostream >头文件以及std标准命名空间**。

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

  2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c

  3. 因为有了命名空间的隔离作用，自定义变量名如果与库里的cout等变量名相同便不会产生冲突，因此实际项目中不要轻易展开命名空间。（日常练习展开则无所谓）

4. 缺省参数

4.1 缺省参数概念

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

#include <iostream>
using namespace std;

void TestFunc(int a = 0)
{
	 cout<<a<<endl;
}
int main()
{
    TestFunc(); // 没有传参时，使用参数的默认值0
    TestFunc(10); // 传参时，使用指定的实参10
}

4.2 缺省参数分类

  • 全缺省参数：所有参数都赋缺省值
#include <iostream>
using namespace std;
void TestFunc(int a = 10, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

int main()
{
    TestFunc();
    TestFunc(1);
    TestFunc(1, 2);
    TestFunc(1, 2, 3);
    return 0;
}
  • 半缺省参数—缺省部分参数—必须从右往左缺省，且连续缺省
// 1.缺省2个参数
void TestFunc(int a, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

int main()
{
    TestFunc(1);
    TestFunc(1, 2);
    TestFunc(1, 2, 3);
    return 0;
}

// 2.缺省1个参数
void TestFunc(int a, int b, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

int main()
{
    TestFunc(1, 2);
    TestFunc(1, 2, 3);
    return 0;
}

注意：

  1. 半缺省参数必须从右往左依次来给出，不能间隔着给
  2. 缺省参数不能在函数声明和定义中同时出现,推荐写在声明
//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{

}
// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用哪个缺省值
  1. 缺省值必须是常量或者全局变量

image-20220314152841427

  1. C语言不支持（编译器不支持）

4.3 缺省参数的应用

struct Stack
{
    int* a;
    int top;
    int capacity;
};

void StackInit(struct Stack* ps, int capacity = 4) // 缺省参数的应用
{
    ps->a = (int*)malloc(sizeof(int) * capacity);
    ps->top = 0;
    ps->capacity = capacity;
}

void StackPush(struct Stack* ps, int x)
{
    // ...
}

int main()
{
    struct Stack st;
    //StackInit(&st);// 不知道栈最多存多少数据，用缺省值初始化
    StackInit(&st, 100);// 知道栈最多存100数据，显示传值；可以减少增容次数，提高效率
    return 0;
}

5. 函数重载

5.1 函数重载概念

函数重载:是函数的一种特殊情况，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(1, 2);
	Add(1.1, 2.2);

	f();
	f(1);

	f(10, 'A');
	f('A', 10);

	return 0;
}

下列情况是否为函数重载？

// 1、缺省值不同，不能构成重载（与参数类型有关，和参数名字无关）
void f(int b)
{
	cout << "f()" << endl;
}

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

// 2、返回值不同，不能构成重载（调用时不能区分）
sho+rt Add(short left, short right)
{
     return left+right;
}
int Add(short left, short right)
{
     return left+right;
}

// 3、构成重载，但是使用时会有问题 ： f();---调用存在歧义
void f()// 无参
{
	cout << "f()" << endl;
}

void f(int a = 0)// 带参
{
	cout << "f(int a)" << endl;
}

int main()
{
	 f(); // 调用存在歧义
	 f(1);// 可以调用

	return 0;
}

5.2 函数重载原理

C不支持重载 and C++支持重载 的演示

image-20211126222008938

vs根据文件后缀调用相应编译器，.c后缀调用c编译器，.cpp调用C++编译器

Linux不根据文件后缀区分，gcc命令行编译c文件，g++命令行编译C++文件

C不支持重载 and C++支持重载的原因？C++如何支持重载？

程序编译过程：

image-20211127121736368

image-20211127121848165

回顾编译器编译程序的过程：func.h func.c test.c

  1. **预处理：**头文件展开、宏替换、条件编译、去掉注释

    生成：func.i test.i

  2. **编译：**编译器检查语法，生成汇编代码

    生成：func.s test.s

  3. **汇编：**汇编代码转换成二进制机器码

    生成：func.o test.o

  4. **链接：**合并func.o test.o

    生成：a.out

Windows环境下main函数调用f();的过程：

image-20211126234939307

C语言不支持函数重载，编译时两个重载函数的函数名相同，在func.o的符号表中存在歧义和冲突；链接时直接使用函数名标识和查找，也将存在冲突

image-20211127130159801

C++支持重载

g++编译器修饰函数名规则：***_Z + 函数名长度 + 函数名 + 参数首字母***

C++的目标文件符号表不用函数名来简单标识和查找函数，引入***函数名修饰规则***（不同编译器有不同修饰规则）

  • 通过函数名修饰规则，只要参数不同，func.o符号表里重载的函数就不存在二义性和冲突
  • 链接时使用修饰后的函数名进行查找，test.o里的main函数调用两个重载函数时，查找地址也就不存在冲突

image-20211127152843860

解释上图链接过程的地址由来：

  1. 如果当前文件有函数的定义，则编译时直接用函数地址（每个.o文件都会生成符号表 ）
  2. 如果当前文件只有函数声明，则其定义在其他xxx.cpp中，编译时也就没有地址；需要在链接时到其他对应xxx.o的符号表中根据函数修饰名字寻找，这也是链接的重要工作。

vs环境根据文件后缀调用相应编译器：.c文件使用c编译器，.cpp使用C++编译器

Linux不区分文件后缀，gcc使用c编译器，g++使用C++编译器

附另一Linux环境下调试结果：

  1. 实际我们的项目通常是由多个头文件和多个源文件构成，通过C语言阶段学习的编译链接可以知道：【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有 Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
  2. 链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
  3. 链接时，面对Add函数，链接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
  4. Windows下vs的修饰规则非常复杂，而Linux下gcc的修饰规则简单易懂，下面使用gcc演示修饰后的名字。
  5. 下图可以看出gcc的函数修饰后名字不变，而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。
  • 采用C语言编译器编译后结果

image-20211127153925593

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

  • 采用C++编译器编译后结果

image-20211127154114873

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息 添加到修改后的名字中。

  • Windows下名字修饰规则

image-20220314202844387

对比Linux会发现，windows下C++编译器对函数名字修饰非常诡异，但道理都是一样的。

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

【扩展学习：C/C++函数调用约定和名字修饰规则】

[C++函数重载](C++的函数重载 - 吴秦 - 博客园 (cnblogs.com))

[C/C++的调用约定](C/C++ 函数调用约定_狮子的专栏-CSDN博客)

6. 引用

6.1 引用概念

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

类型& 引用变量名(对象名) = 引用实体；

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    // 引用定义
    // 注意：引用类型必须和引用实体是同种类型的
    int& b = a;

    // 取地址
    int* p = &b;

    return 0;
}

image-20220314205047147

image-20220314205333839

引用在语法层，理解为并未开辟新空间，只是对原有的变量取了一个新名称

6.2 引用特性

  1. 引用在定义时必须初始化
  2. 一个变量可以有多个引用
  3. 引用一旦引用一个实体，再不能引用其他实体
int main()
{
    // 1.引用在定义时必须初始化
    int a = 10;
    int& b; // 该条语句编译时会出错

    // 2.一个变量可以有多个引用
    int a = 10;
    int& b = a;
    int& c = a;
    int& d = b;

    // 3. 引用一旦引用一个实体，再不能引用其他实体
    int a = 10;
    int& b = a;

    int c = 20;
    b = c;
          // 可能存在2种含义：
          // 1、将b作为c的别名？否
          // 2、把c赋值给b？是

    int* p1 = &a;
    p1 = &c;// 相比之下，指针指向会发生变化
    return 0;
}

image-20220314211303495

6.3 使用场景

  1. 做参数
// 传址 _Z4swappipi
void Swap(int* p1, int* p2)
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

// 传引用 _Z4swapriri
void Swap(int& r1, int& r2)
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

// 传值 _Z4swapii
void Swap(int r1, int r2)
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

// 3个构成重载
// 但Swap(x,y)调用时存在歧义，究竟调用传值还是传引用
// 类似之前所讲：以下2个构成重载，但调用存在歧义
// void f();
// void f(int x = 0, int y = 0);

int main()
{
    int x = 0, y = 1;
    Swap(&x, &y);
    Swap(x, y);

    return 0;
}

int main()
{
    int a = 10;
    int& b = a;

    int* p1 = &a;
    int*& p2 = p1;

    return 0;
}

image-20220314232056085

在引用的用法之前，传二级指针

image-20220315233430183

引用的实例：传一级指针的别名

phead（形参）是plist（实参）的别名，phead的改变就是改变plist

image-20220315233527271

SLTNode* 还可以在typedef时取新的名字

引用做参数的实例还有2个：（视频 11-28-C++基础续50‘）

  • 剑指Offer 56 数组中数字出现的次数 输出型参数
  • 清华大学 二叉树遍历
  1. 做返回值

以下先看函数栈帧中所讲过的传值返回：

所有的传值返回都会生成一个拷贝

  • c不做返回值：

    因为Add函数执行完时，函数栈帧销毁；c的值拷贝在临时变量内作为返回值

  • 临时变量存在哪？

    1、c如果比较小（4/8byte），一般是寄存器充当临时变量

    2、c如果比较大，临时变量放在调用Add函数的栈帧中

image-20220316154257999

传引用返回：

当前代码的问题：

1、存在非法访问，因为Add(1,2)的返回值是c的引用，所以Add栈帧销毁以后，会去访问c位置空间

2、如果Add函数栈帧销毁，清理空间，那么取到的c值是随机值，ret也就是随机值（ps：是否清理空间数据取决于编译器，vs环境下销毁栈帧不清理）

3、物理上不存在tmp的空间，tmp相当于c的别名

image-20220318110120483

以上代码暂不报错

但是下面代码有错误生成：

image-20220316160446304

栈帧的使用：

调用完销毁；如果还有新的调用，可以使用已经销毁的栈帧空间

下图说明：如果新调用的函数栈帧空间覆盖了原有空间，将影响原先的c（ret）值

image-20220316161328607

比喻：对内存的使用就像“租房子”一样，可重复使用

因此，慎用引用返回！

传值返回和传引用返回的区别：

以下举例说明：如果函数返回时，出了函数作用域，如果返回对象（属于静态变量、全局变量）还未还给系统，则可以使用引用返回；如果已经还给系统了，则必须使用传值返回。

// 传引用返回
int& Count()
{
 static int n = 0；
 n++;
 // ...
 return n;
}

// 传引用返回示例2
int& f()
{
    int* p = (int*)malloc(4);
    return *p;// 注意返回的是指针指向的空间
}

// 传值返回
int Add(int a, int b)
{
    int c = a + b;
    return c;
}

6.4 传值、传引用效率比较

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

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2(a);
    size_t end2 = clock();
    // 分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
    TestRefAndValue();
    return 0;
}

image-20220316165457960

#include <time.h>
struct A{ int a[10000]; };
A a;
// 值返回---每次拷贝40000byte
A TestFunc1() { return a;}
// 引用返回---无拷贝
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
 // 以值作为函数的返回值类型
 size_t begin1 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc1();
 size_t end1 = clock();
 // 以引用作为函数的返回值类型
 size_t begin2 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc2();
 size_t end2 = clock();
 // 计算两个函数运算完成之后的时间
 cout << "TestFunc1 time:" << end1 - begin1 << endl;
 cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

image-20220316165120353

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

**总结：**引用的作用主要体现在传参和传返回值

1、引用传参和传返回值，有些场景下面可以提高性能。（大对象+深拷贝对象）

2、引用传参和传返回值，输出型参数和输出型返回值。通俗地说，引用传参，有些场景下，形参的改变可以改变实参；引用传返回值，有些场景下，引用返回可以修改返回对象。

以下是修改返回对象示例：

image-20220318124012269

const int N = 10;

int& At(int i)
{
    static int a[10];
    return a[i];
}

int main()
{
    for (size_t i = 0; i < N; ++i)
    {
        At(i) = 10 + i;
    }

    for (size_t i = 0; i < N; ++i)
    {
        cout << At(i) << " ";
    }
    cout << endl;

    return 0;
}

右值：表达式产生的临时变量、常量

右值不可以修改

*后续有学

6.5 常引用

int main()
{
	// 权限放大
    const int a = 10;// 权限只读
    int& b = a;// 权限可读可写，编译将报错
    
    // 权限不变 可以
    const int a = 10;
    const int& b = a;
    
    // 权限缩小 可以
    int c = 10;
    const int& d =c;
    
    double d = 11.11;
    int i1 = d;// 发生隐式类型转换
    int& i2 = d;// error
    const int& i3 = d;// 类型转换会产生临时变量，引用的是带常性的变量，必须带const修饰
    
	return 0;
}

image-20220318130524842

再举一例说明const常引用：

int x1 = 1,x2 = 2;
const int& ret = x1 + x2;// x1+x2的值是临时变量（右值），引用时加const

假设x是一个大对象或者后面学习的深拷贝对象

使用引用传参，如果函数中不改变参数值x，尽量用const引用传参，同时也能减少拷贝

const Type & 可以接收各种类型的对象

// 常引用示例：
void f(const int& x)
//void f(int& x) // 不加const将报错，权限不对应
{
    cout << x << endl;
}

int main()
{
	// 权限放大
    const int a = 10;// 权限只读
    int& b = a;// 权限可读可写，编译将报错
    
    // 权限不变 可以
    const int a = 10;
    const int& b = a;
    
    // 权限缩小 可以
    int c = 10;
    const int& d =c;
    
    f(a);
    f(c);
    
	return 0;
}

6.6 指针和引用的区别

引用和指针的不同点:

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

  2. 引用在定义时必须初始化，指针最好初始化，但不初始化也不会报错

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

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

  5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

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

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

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

  9. 引用比指针使用起来相对更安全，指针要考虑空指针、野指针等问题

    image-20220318133715412

**总结：**指针相比引用，使用更复杂，更容易出错。面试经常考察两者区别，理解记忆。

了解一下即可，使用时不去考虑底层汇编实现

image-20220319150123603

语法层：

指针和引用是完全不同的概念

指针是开空间，存储变量地址

引用不开空间，仅仅是对变量取别名

底层汇编实现时：

引用是用指针实现的

下图说明：sizeof(引用变量)的大小是变量的大小

image-20220319150002408

7. extern “C”

C++项目中调用由C实现的静态库

  • 包含头文件
  • C++项目工程属性中配置静态库的目录和添加静态库

image-20220318153451309

链接需要注意添加静态库目录：Debug目录下是.lib文件

image-20220318151328238

添加静态库

image-20220318151652843

此时链接仍会报错，因为静态库内C语言的函数修饰规则和调用时C++的函数修饰规则不一样。

extern "C"的作用是告诉C++编译器括号内的函数由C编译器编译，链接时用C的函数名规则寻找

image-20220318152840972

C项目中调用由C++实现的静态库

image-20220318162454394

写法一：

C++程序预定义了标识符__cplusplus

C++程序内展开extern “C”，此时函数不再支持函数重载

image-20220318162029130

写法二：

C++程序内展开extern “C”，C程序内宏替换为空

image-20220318162310827

总结：

C++程序调用C的库，在C++程序中加extern “C”

C程序调用C++的库，在C++库中加extern “C”

8. 内联函数

调用函数需要建立栈帧，栈帧中要保存一些寄存器，结束时再恢复…

像以下频繁调用函数对内存有一定消耗。

int Add(int x, int y)
{
    int ret = x + y;
    return ret;
}

int main()
{
    Add(1, 2);
    Add(1, 2);
    Add(1, 2);
    Add(1, 2);
    Add(1, 2);
    Add(1, 2);
    return 0;
}

C语言提供了“宏”进行优化

#define ADD(x, y) ((x) + (y))// 宏的原理是替换

int main()
{
    cout << ADD(1, 2) << endl;
    int a = 0, b = 1;
    cout << ADD(a | b, a & b) << endl;
}

8.1 概念

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

以下是普通函数调用，需要建立栈帧

image-20220318195512455

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

查看方式：

  1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
  2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2019的设置方式)

image-20220318195641523

image-20220318195724926

image-20220318195851196

inline int Add(int x, int y)
{
    int ret = x + y;
    return ret;
}

int main()
{
    int ret = Add(1, 2);
    cout << ret << endl;
    return 0;
}

8.2 特性

  1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长（10行以上）或者有循环/递归的函数不适宜使用作为内联函数。

    image-20220318212647498

  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略掉内联。

  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

    // F.h
inline void f(int i);

// F.cpp
#include <iostream>
using namespace std;
#include "F.h"

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

// main.cpp
#include "F.h"
int main()
{
 f(10);
 return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

    f.cpp->f.o时，符号表中不会生成f函数的地址，因为inline函数不需要地址，都在调用的地方展开了

**结论：**短小、频繁使调用的函数建议定义成inline

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

9.1 auto简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。

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

int main()
{
    int a = 0;
    auto b = a;// 自动推导b的类型 - int
    auto c = 'A';// 自动推导c的类型 - char
    auto d = 10.11;// 自动推导b的类型 - double

    // auto省略了const属性
    
    // typeid打印变量的类型
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    cout << typeid(d).name() << endl;
    return 0;
}

image-20220319152630276

#include <iostream>
#include <map>
#include <string>

int main()
{
    // 实际中auto的使用场景
    std::map<std::string, std::string> dict = { {"sotr","排序"},{"insert","插入"} };
    //std::map<std::string, std::string>::iterator it = dict.begin();
    auto it = dict.begin();// 相比上一行写法，auto根据右边的值自动推导it的类型，更简略

    return 0;
}

【注意】

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

9.2 auto的使用细则

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

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

int main()
{
    int x = 10;
    auto a = &x;// 取地址，int*
    auto* b = &x;// 仍是int*
    auto& c = x;// c是x的引用，类型：int

    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;

    *a = 20;
    *b = 30;
    c = 40;

    return 0;
}

image-20220319160911026

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

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

int main()
{
	auto a = 1, b = 2; 
	auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
    
    return 0;
}

9.3 auto不能推导的场景

  1. auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
  1. auto不能直接用来声明数组
void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}
  1. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
  2. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

10. 基于范围的for循环(C++11)

10.1 范围for的语法

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中 引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量， 第二部分则表示被迭代的范围。

**注意：**与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

int main()
{
    int array[] = { 1,2,3,4,5 };
    // C/C++遍历数组
    for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
    {
        cout << array[i] << endl;
    }

    // C++11 范围for
    // 自动依次取数组array中的每个元素赋值给x
    //for (int x : array)
    for (auto x : array)
    {
        cout << x << endl;
    }

    // 范围for 把数组中每个值+1
    // e的生命周期只在单词循环内，而不是整个循环过程
    for (auto& e : array)
    {
        e++;
    }

    for (auto e : array)
    {
        cout << e << endl;
    }
    return 0;
}

10.2 范围for的使用条件

void TeatFor(int a[])
{
    // 范围for必须是数组名,数组传参却变成了int*
    for (auto& e : a)
    {
        cout << e << endl;
    }
}

int main()
{
    int array[] = { 1,2,3,4,5 };
    TeatFor(array);
}

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

11.1 C++98中指针空值的定义

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

int main()
{
    // C++98/03
    int* p1 = NULL;
    int* p2 = 0;

    //C++11，初始化空指针推荐用法
    int* p3 = nullptr;

    return 0;
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，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);
    f(nullptr);// C++11
    return 0;
}

image-20220319193439191

程序本意是想通过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。
wcsq0523
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础知识【C++入门】
evoke_c的博客
02-13 1983
1、C++输入&输出 新生婴儿会以自己独特的方式向这个崭新的世界打招呼，C++刚出来后，也算是一个新事物， 那C++是否也应该向这个美好的世界来声问候呢？我们来看下C++是如何来实现问候的。 #include<iostream> using namespace std; int main() { cout<<"Hello world!!!"<<endl; return 0; } 说明： 使用cout标准输出(控制台)和cin标准输入(键盘) 时
c++基础
lqjzb的博客
04-05 7790
一、循环结构 1.while循环 ()中填的是循环条件 避免死循环出现 #include<iostream> using namespace std; int main(){ //输出0~9 int num = 0; while (num<10) { cout << num << endl; num++; } system("pause"); return 0; } //结果为0~9的一列 例子：猜数字 #include&l
C++的#include ＜iostream＞详解
2201_75598244的博客
07-24 7939
命名空间是C++的一种机制，用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。包含了iostream也自动包含了ios、streambuf、istream、ostream和iosfwd。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。，在这个函数中用于提取iostream文件中的代码，并编译使用其输出功能。在 cout （输出）中每一个不同类型的数据之间都要用。同时在 cin（输入）中每一个不同类型的数据之间都要用。源文件带来的功能，用于输出“指定数据”到窗口中。
c++的HelloWorld编写及解释：#include iostream、using namespace std
mantou_riji的博客
03-09 8459
#include <iostream> using namespace std; int main() { cout << "Hello world!" << endl; return 0; } 解释： （1）#include iostream #include <iostream> 以#开头的语句称为预处理器指令； #include语句不是必须的，但是如果一旦程序中有该语句，就必须将它放在程序的开始处。 iostream是input
C++入门PPT
12-03
以下将根据标题“C++入门PPT”和描述，详细阐述C++学习的关键知识点。 1. **基础语法**：C++的语法结构与C语言类似，包括变量声明、数据类型（如int、float、char）、运算符（算术、比较、逻辑等）、流程控制（if-...
C++入门经典(第10版)-沃特·萨维奇 (Walter Savitch).rar
07-04
《C++入门经典》是C++编程语言领域的一本知名教材，由沃特·萨维奇（Walter Savitch）撰写，已经更新至第10版。这本书被广泛用于初学者学习C++的基础知识，因其易懂且实用的特性而备受推崇。 C++是一种通用的、面向...
C++入门编程100题
06-30
《C++入门编程100题》课程是由WangTeacher精心制作一部视频教学实战课程，初步计划100个编程题目的详细讲解，从简单到复杂的顺序排列。并结合15+年的软件开发经验，把最先进的软件开发流程和编程技巧融合到课程中，...
C++入门经典(第4版)
07-26
C++入门经典(第4版)
C++入门教程
10-23
C++Primer4高清版，入门推荐。原著Stanley B.Lippman, Jose Lajoie, Barbara E.Moo
C++基本框架：# include ＜iostream＞
2302_80203140的博客
10-16 1169
给代码加上的一些解释部分，不会被编译器识别，不会进入到编译过程中去。单行注释使用 //（文字）多行注释使用 /* （文字）*/
我们常用的#include＜iostream＞、using namespace std；到底是什么？
zhangyimin2011的博客
06-23 2347
，之所以出来这样一个东西，是因为人类可用的单词数太少，并且不同的人写的程序不可能所有的变量都没有重名现象，对于库来说，这个问题尤其严重，如果两个人写的库文件中出现同名的变量或函数(不可避免)，使用起来就有问题了。或者说，我要用一个叫“a”的工具，它在一个叫“abc”的工具箱里，那我必须要先找到abc才能找到a工具。比如，我写了个程序，要用一个叫a的函数，它在一个叫“abc”的库里，那我要使用a函数，那么必须要调用abc库。包含”的意思，而#符号是C++中“预处理”的意思，那“预处理”又是个什么？
#include＜iostream＞
小秋 AI SLAM 入门实战教程
05-09 4179
库提供了C++程序中用于处理标准输入/输出流的基本功能。这个库中定义了一些重要的类和对象，以及与输入/输出相关的函数。类：这是一个输入流类，用于从输入设备（如键盘、文件等）读取数据。类：这是一个输出流类，用于向输出设备（如屏幕、文件等）写入数据。这些类分别用于处理字符串流、文件输入流和文件输出流。类型的对象，表示标准错误流。类型的对象，表示标准输入流（通常是键盘输入）。类型的对象，表示标准输出流（通常是屏幕输出）。库还包括了其他与流处理相关的类，例如。类型的对象，表示标准日志流。类似，但用于输出日志消息。
C++基础入门
爹爹的博客
08-02 1105
目录c++关键字命名空间C++输入&输出缺省参数函数重载 c++关键字 C++总计63个关键字，C语言32个关键字 命名空间 使用命名空间的目的是对标识符的名称进行本地化，用来避免命名冲突或名字污染，namespace的关键字的出现就是针对这种问题的。 1.1 命名空间的定义 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。 //1.普通的命名空间 namespace Sb //Sb为命名空间的名称 { //命名空间中的内容，
C++标准库头文件解释
yjj1123456的博客
05-13 8917
是C++标准库中的头文件，它提供了许多用于处理字符串的函数和操作。头文件，我们可以使用上述函数和操作来处理字符串，执行各种字符串相关的任务，如复制、连接、比较、查找等。是C++标准库中的头文件，它提供了许多常用的算法函数，用于对数据进行排序、查找、变换和操作等操作。头文件，我们可以使用上述函数和操作来对数据进行各种常见的算法处理，如排序、查找、统计、变换等。是C++编程语言中的一个预处理指令，用于包含 C-style 字符串处理函数的头文件。是C++标准库中的头文件，它包含了输入输出流的定义，包括了。
C++初探究（2）
最新发布
Frenemy__的博客
07-09 729
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++入门基础_30分钟入门教程
09-22
C++入门基础 C++是一门应用非常广泛的计算机程序设计语言，它既支持过程化程序设计，也支持面向对象程序设计。从操作系统、设备控制到数据库、网络、多媒体等众多的应用领域都能看到它的身影。 **1. C++概述** ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值