文章目录
前言：C++是在C的基础上，容纳进去面向对象编程的思想，并增加了许多有用的库，以及编程范式。熟悉C语言之后，对C++学习有一定的帮助，本章节主要讲述C语言语法的不足，以及C++是如何对C语言一些不合理的地方进行优化的，为后续类和对象的学习打下基础。
1. 命名空间
在C/C++中，会存在很多变量，函数，以及随后要学到的类，如果我们都将它们存放在全局域中，可能会导致很多冲突。所以使用命名空间的目的是对标识符进行本地化，以避免命名冲突或者名字污染
#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
printf("%d\n",rand);
//显然这里定义的全局的rand与库里的rand函数
//重名,编译器就会报错
return 0;
}
1.1 命名空间定义
定义命名空间，需要使用namespace关键字，后面跟命名空间的名字，然后加一对{}，{}内的即为命名空间的成员。
//test.cpp
#include <iostream>
#include <stdlib.h>
namespace name1
{
//1.命名空间可以定义变量/函数/类型
int rand = 0;
int x = 0;
int Add1(int a,int b)
{
return a + b;
}
struct Node
{
struct Node* next;
int val;
};
}
//2.命名空间可以嵌套
namespace name2
{
int a;
int b;
int Add2(int a,int b)
{
return a + b;
}
namespace name3
{
int a;
int b;
int Sub(int a,int b)
{
return a - b;
}
}
}
//3.一个工程中可以含有多个名称相同的命名空间(比如说test.h和test.cpp中都含有同一命名空间name1)，
//但是编译器最后会合成到同一个命名空间中，只要空间内命名不相同即可
//注意:一个命名空间就定义了一个新的作用域，命名空间的所有内容都局限于该命名空间中
//test.h
namespace name1
{
int Sub(int a,int b)
{
return a - b;
}
}
1.2 命名空间使用
命名空间的使用有三种方法：
1. 命名空间名称加作用域限定符
namespace name
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
int main()
{
printf("%d\n",name::a);
return 0;
}
2. 使用using将命名空间中某个成员引入
using name::b;
int main()
{
printf("%d\n",N::a);
printf("%d\n",b);
return 0;
}
3. 使用using namespace 命名空间名称引入
using namespace name;
int main()
{
printf("%d\n",N::a);
printf("%d\n",b);
Add(10,20);
return 0;
}
using namespace std;
std是所有C++标准库的命名空间，C++将标准库的定义，实现都放在了这个命名空间中。
#include<iostream>
using namespace std;//将库的命名空间打开，也就是将std空间的内容放置全局域
//中
int main()
{
cout << "hello world" <<endl;
std::cout << "hello world" <<endl;//使用指定的命名空间
return 0;
}
但是一般在项目中，不建议将std这个命名空间展开，一般都是用命名空间名称加类作用域限定符
2. C++输入&输出
先举例上代码讲解
#include <iostream>
using namespace std;
int main()
{
cout << "hello world" << endl;
int i = 100;
//流插入运算符
cout << i << endl;
//流提取运算符
cin >> i;
double d = 1.11111;
cout << d << endl;
//如果需要保留几位小数的时候，还是尽量用printf更方便
printf("%.2lf\n",d);
return 0;
}
说明：
- 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含 < iostream > 头文件以及按照命名空间的使用方法使用std
- cout和cin都是全局的流对象，endl是特殊的C++符号，表示换行，也都包含在 < iostream >
- <<是流插入运算符 ，>>是流提取运算符
- C在使用scanf和printf输入和输出的时候，需要去手动控制格式
而cout和cin在输入和输出的时候，可以自动识别变量的类型，不需要手动控制格式，
3. 缺省参数
3.1 缺省参数的概念
缺省参数是指在声明或者定义函数时为函数的参数指定一个缺省值。
在调用该函数时，如果没有指定实参的话就采用该形参的缺省值，否则就是用指定的实参
void Func(int a = 0)
{
cout<<a<<endl;
}
int main()
{
Func(); // 没有传参时，使用参数的默认值
Func(10); // 传参时，使用指定的实参
return 0;
}
3.2 缺省参数分类
全缺省参数
void Func(int a = 10,int b=20,int c=30)//缺省参数
{
cout <<"a="<< a << endl;
cout <<"b="<< b << endl;
cout <<"c="<< c << endl << endl;
}
半缺省参数
void Func(int a , int b = 20, int c = 30)//b,c缺省参数
{
cout << "a=" << a << endl;
cout << "b=" << b << endl;
cout << "c=" << c << endl << endl;
}
int main()
{
Func(1, 2, 3);
Func(1, 2);
Func(1);
return 0;
}
这里注意
- 参数只能从左到右连续给，不能隔着给
- 缺省参数不能在函数声明和定义中同时出现
- 缺省值必须是常量或者全局变量
4.函数重载
4.1函数重载概念
函数重载：是函数的一种特殊情况，C++允许在同一个作用域中，声明几个功能类似的同名函数。要求：函数名相同，参数不同，进而构成函数重载。
注意：在C中，是不允许存在同名函数的出现
参数不同分为：参数类型不同，参数个数不同，参数顺序不同
#include<iostream>
//1. 参数的类型不同
int add(int left, int right)
{
cout << "int add(int left,int rigth)" << endl;
return left + right;
}
double add(double left, double right)
{
cout << "double add(double left,double rigth)" << 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()
{
cout << add(1, 2)<< endl;
cout << add(1.2,1.5) << endl;
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}
4.2 C++支持函数重载的原理–名字修饰
这里以Linux上的代码为例：
int Add(int a,int b)
{
return a + b;
}
void func(int a,int b,int *p)
{}
int main()
{
Add(1,2);
func(1,2.0,0);
return 0;
}
将上述代码利用C语言编译器编译后的结果：
可见在Linux下，采用gcc编译完成后，函数名字的修饰没有发生改变
采用C++编译器编译后的结果：
在Linux下，采用g++编译完成之后，函数名字的修饰发生改变，编译器将函数参数类型的信息添加到修改后的名字中。所以在C++中，构成函数重载的函数，由于参数不一样，最终编译后形成名称也不一样，进而区分出同名函数
总结：通过上面我们可以看出gcc的函数修饰的名字不变，而g++的函数修饰后变成[_Z+函数长度+函数名+类型首字母]。
通过这里就理解了C语言没办法支持重载，因为同名函数无法区分，而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，因此也就支持重载了
5.引用
5.1引用概念
引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间
使用说明：
类型& 引用变量名=引用实体
注意引用变量名的类型要与引用实体类型一致
例如：
void Test()
{
int a = 10;
int& ra = a;//ra是a的别名
printf("%p\n",&a);
printf("%p\n",&ra);//这里打印的地址是一样的
}
5.2 引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体，就不能再引用其他实体
为了避免误导到大家，下面给出正确的使用方法
int main()
{
int a = 0;
int& b = a;//1.引用在定义时必须初始化
int& c = a;//2.引用在定义之后，不能改变指向，也就是说一旦引用了一个实体，那就不能引用其他 实体了
int d = 2;
c = d;//这里不是改变指向，而是赋值
int& e = a;//一个变量可以有多个引用，多个别名
return 0;
}
5.3 常引用
void test()
{
const int a = 10;
const int& ra = a;//a为常量，a不能被修改，所以前面应该加上const
const int& b = 10;//同上
double d = 12.34;
double& rd = d;//引用变量类型要与引用实体类型一致
}
5.4 使用场景
1.做参数(a.输出型参数 b.对象比较大，减少拷贝，提高效率)
void Swap(int& a,int& b)
{
int t = a;
a = b;
b = t;
}
这些效果，指针也可以，但是引用更加方便
2.做返回值
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
//Add函数运行完结束后，该函数对应的栈空间就被回收了，即变量c就没有意义了
//但是注意空间被回收，指的是空间不能够再使用了，但是空间本身还存在，而ret引用的c的空间被修改成7，因此ret的值也变成7了
cout << ret << endl;//ret=7
}
注意：1.函数运行时，系统需要给函数开辟独立的栈空间，用来保存该函数的形参，局部变量，以及一些寄存器的信息等
2.函数运行结束后，该函数对应的栈空间就被系统回收了
3.空间被回收==这块栈空间暂时不能使用，但是在内存中还存在
总结：如果函数返回时，出了作用域，如果返回的对象还在(还没还给操作系统)，则可以引用返回，如果已经还给操作系统了，那就必须使用传值返回
5.5传值，传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就会更加低
5.6指针和引用的区别
语法上：
1.引用是别名，不开空间，而指针是地址，需要开空间存地址(这里注意在底层实现是有空间的，因为在底层引用是按照指针方式来实现的)
2.引用在使用时必须初始化，而指针可以初始化也可以不初始化
3.引用在初始化之后不能改变指向，指针可以
4.引用相对更加安全，没有空引用，但是有空指针，容易出现野指针但不容易出现野引用
5.sizeof 的含义不同，引用的结果为引用类型的大小，而指针是地址所占字节的个数
6.++引用自加即引用的实体加1，而指针自加即指针向后偏移一个类型的大小
7.解引用访问等方面的区别：
指针需要显式解引用，引用只需要编译器自己处理
在底层上：
没有引用，都是指针，引用经过编译之后也转换成指针
6. 内联函数
6.1 概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数可以提升程序的运行效率。
#include <iostream>
using namespace std;
inline int Add(int a,int b)
{
return a + b;
}//该函数在编译期间会用函数体替换函数的调用
int main()
{
int ret = 0;
ret = Add(1，3)；
return 0;
}
6.2特性
1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能是目标文件变大，优势：减少的调用开销，提高程序运行效率
2.inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模比较小，不是递归，且频繁调用的函数采用inline修饰，否则编译器会忽略inline的特性
3.inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，链接就会找不到
扩展：
宏函数
优点：1.增强代码的复用性，2.提高性能
缺点：1.不方便调试(因为预编译期间就对宏进行了替换)
2.代码可读性差，可维护性差，细节比较多，容易误用
3.没有类型安全的检查
C++有哪些技术可以替换宏？
1.常量定义换用const enum
2.短小函数定义换用内联函数
7.auto关键字
7.1 auto简介
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替换为变量实际的类型
7.2 auto的使用细则
1.auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有区别，但用auto声明引用类型时必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
2.在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
void test()
{
auto a = 1,b = 2;
auto c = 3,d = 1.0;//该行代码会编译失败，因为c和d初始化表达式类型不同
}
7.3 auto不能推导的场景
1.auto不能作为函数的参数
2.auto不能直接用来声明数组
8基于范围的for循环
8.1范围for的语法
对于一个有范围的集合而言，for循环后的括号有冒号 ：分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围
例如：
void TestFor()
{
int arr[] = {1,2,3,4,5};
for(auto e : arr)
cout << e << endl;
}
注意：与普通的for循环类似，可以用continue来结束本次循环，也可以用break来终止整个循环
8.2范围for的条件
1.for范围迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围，对于类而言，应该提供begin和end的方法，begin和end就是foe循环迭代的范围
2.迭代的对象要实现++和==的操作
9 空指针nullptr
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);
return 0;
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的
初衷相悖。
注意：
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入
2.在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同
3.为了提高代码的健壮性，在后续表示指针空值时虽好使用nullptr
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
