C++基础语法讲解
- 前言
- 1.输入输出
- 2.命名空间
- 2.1命名空间的理解：
- 2.2命名空间的使用方式
- 3.缺省参数
- 3.1概念：
- 3.2分类：
- 半缺省函数注意事项：
- 3.3使用案例：顺序表的初始化
- 4.函数重载
- 4.1参数重载类型类型：
- 5.引用
- 5.1概念
- 5.2特性
- 5.3常引用
- 5.4使用场景
- 5.5效率比较
- 5.6使用实例
- 5.7引用和指针的比较
- 语法：
- 底层：
- 6.内联函数
- 6.1概念语法：
- 6.2特性
- 6.3宏和内联的区别
- 7.auto关键字（C++11）
- 8.基于范围的for循环（C++11）
- 8.1语法：
- 8.2实例：
- 9.指针控制nullptr（C++11）
前言
C++出现的本质就是解决C语言的一些不足和缺陷，由于新添加的内容过多，从而生成了一门独立的语言，下面我们来介绍一下C++和C原因呢基础语法的不同。
1.输入输出
在这里只是简单介绍其用法。
在C语言中，scanf和printf使用时需要%d %s等，比较麻烦，因此C++实现了cin和cout来使输入输出更加简单。
使用事项：
1.输入使用cin,输出使用cout，cin相当于C语言中的scanf，cout相当于C语言中的cout
2.包含头文件
3.使用命名空间std
#include<iostream>
using namespace std;
int main()
{
int i = 0;
cin >> i;
cout << i << endl; //endl相当于C语言中的\n，表示换行
}
2.命名空间
在C语言中，函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。无论是变量命名还是函数命名都不能和C语言的关键字相同，比如用int类型来定义rand，在C语言中就会报错，因为其和库函数中的rand函数名重定义。
2.1命名空间的理解：
如何理解命名空间？命名空间就相当于给这一块地方确定主人。
比如有一个小区，在C语言中就相当于这个小区最开始是没有主人的，如果有人先来霸占了这个小区，那么别人就不能再来抢占这个房子，这个小区只归这一个财大气粗的老板拥有，这个小区里面的东西就全部归这个老板所有，这就和C语言中中的命名冲突问题相同。而在C++中，就好比如这个老板将小区中的房子进行出租（可以将所有的区域划分），那么如果有人买了这个房子，这个房子就归属于买家，而被购买房子中的物品就属于卖家。比如有相同的电视，就可以通过是户主的还是老板的来区分开来，这样就可以拥有相同的东西（即变量和方法）。
特点：
通过上述解释可以理解
1.可以定义同名的命名空间，最终编译器会进行合并
可以理解一个人可以购买多个房间，如果把所有房子都卖了，那么钱都会给到原户主
2.命名空间可以嵌套
可以理解为这个房子中其中一个是孩子的，一个是父母的。
编译器的搜索原则：
先局部再全局，如果指定直接去指定域内搜索
2.2命名空间的使用方式
方式一：
加命名空间以及域访问限定符
就相当于指定是哪一家的什么物品。
namespace A
{
int a = 0;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
cout << A::add(1,3) << endl;
}
方式二：使用using将命名空间中需要使用的某个成员引入
引入后就可以不需要添加访问限定符,可以更加简洁
using A::add;
namespace A
{
int a = 0;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
//cout << A::a << endl; //由于未引入，会报错
cout << add(1,3) << endl;
}
方式三：使用using namespace 命名空间名称将命名空间所有成员引用
using namespace A;
namespace A
{
int a = 0;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
//cout << A::a << endl;
cout << a << endl;
cout << add(1,3) << endl;
}
注意：using namespace std
std是C++中的库的命名空间，将其放开才可以使用C++中的库函数，如cin和cout。
3.缺省参数
3.1概念：
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
可以理解为你给我就要，你不给我也有。
3.2分类：
全缺省参数：所有的参数都给了缺省值
void print(int x = 5, int y = 10, int z = 20)
{
cout << "x:" << x << endl;
cout << "y:" << y << endl;
cout << "z:" << z << endl;
}
半缺省参数：部分参数给出了缺省值
半缺省函数注意事项：
1.只能从右往左依次给缺省值，不能跳跃给
//会报错
void print(int x, int y = 10, int z)
{
cout << "x:" << x << endl;
cout << "y:" << y << endl;
cout << "z:" << z << endl;
}
//正确
void print(int x, int y = 10, int z = 20)
{
cout << "x:" << x << endl;
cout << "y:" << y << endl;
cout << "z:" << z << endl;
}
2.缺省参数不能在函数声明和定义同时出现，应该给在函数定义处
为了防止两处的缺省值不同导致编译器不能分辨
3.3使用案例：顺序表的初始化
如果我们已经知道栈的大小的大致范围，我们可以在初始化时直接开辟足够多的空间，这样就能减少后面的扩容次数。
//seqList.h
typedef struct seqList
{
int* a;
int size;
int capacity;
}SL;
//原始版本，申请的空间定死
//void Init(SL* psl)
//{
// psl->a = (int*)malloc(sizeof(int) * 4);
// psl->size = 0;
// psl->capacity = 4;
//}
void Init(SL* psl, int n = 4);
//seqList.cpp
void Init(SL* psl, int n)
{
psl->a = (int*)malloc(sizeof(int) * n);
psl->size = 0;
psl->capacity = n;
cout << n << endl;
}
int main()
{
SL s;
Init(&s); //不指定参数，n默认取4
Init(&s, 100); //指定参数 ，n取100
return 0;
}
4.函数重载
在C++中支持实现函数名相同的函数
4.1参数重载类型类型：
1.参数类型不同
2.参数个数不同
3.参数类型顺序不同
如果参数个数相同时，但是参数类型不同，那么参数顺序不同也会构成函数重载
4.注意：函数参数相同，但是返回类型不同不构成函数重载
//原函数
int add(int x, int y)
{
return x + y;
}
//参数类型不同
double add(double x, double y)
{
return x + y;
}
//参数个数相同，类型相同，参数顺序不同
int add(double x, int y)
{
return x + y;
}
int add(int x, double y)
{
return x + y;
}
//参数个数不同
int add(int x, int y,int z)
{
return x + y + z;
}
//不构成重载
double add(int x, int y)
{
return x + y;
}
5.引用
5.1概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，江湖上人称"黑旋风"。"黑旋风"和李逵指的是同一个人，只是两种不同的叫法。
语法：类型& 引用变量名(对象名) = 引用实体；
int i = 0;
int& b = a; //b是a的引用
5.2特性
1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用不能被修改
//int& d; 引用必须初始化，否则报错
int a = 0;
int& b = a; //b是a的引用
int& d = a;
cout << b << endl;
int c = 3;
b = c; //把c赋值给b，而不是让b成为c的别名
cout << b << endl;
5.3常引用
void func(const int& x)
{
}
int main()
{
int a = 0;
//int& b = a; //权限平移
//int& b = 10; //权限放大,会报错 10具有常性
const int& b = 10;
//int& c = 10 + a; //表达式的返回值为临时变量，临时变量具有常性
const int& c = 10 + a;
//类型转换会产生临时变量，临时变量具有常性
double d = 1.12;
int e = d; //产生int类型的临时变量，来接收d的整型部分，再赋值给e
//int& f = d; //报错，权限放大，而不是因为类型不同
const int& f = d;
func(10); //如果函数参数不加const修饰，权限放大，会报错
return 0;
}
总结：
1.const修饰的变量只能实现权限缩小和平移，不能实现权限放大
2.临时变量具有常性，在类型转换时会有类型提升和截断。
5.4使用场景
1.做参数
在C语言中，如果要修改当前变量则会传入指针做参数，现在可以直接使用引用作为参数修改变量。
2.做返回值
不能返回局部变量的引用，可以返回静态，全局变量的引用，因为这两个出了该函数作用域后不会销毁。
优点：
1.可以修改返回的对象
2.可以减少拷贝，提高效率
int& Count()
{
static int n = 0;
n++;
// ...
return n;
}
int& Add(int a, int b)
{
int c = a + b;
//c是临时变量，出了作用域就会销毁，返回它的引用则会产生野引用
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl; //输出值是随机值
return 0;
}
//顺序表获取pos位置元素
int& getElement(SL& psl, int pos)
{
//传入的是引用，数组是malloc出来的，不会销毁，所以可以实现可读可写
return psl.a[pos];
}
5.5效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
5.6使用实例
void Init(SL& sl, int n)
{
sl.a = (int*)malloc(sizeof(int) * n);
sl.size = 0;
sl.capacity = n;
cout << n << endl;
}
int& add(int x, int y)
{
//返回局部变量的地址,会出现野引用
int sum = x + y;
return sum;
}
void push(SL& psl, int x)
{
//扩容...
psl.a[psl.size++] = x;
}
int& getElement(SL& psl, int pos)
{
//传入的是引用，数组是malloc出来的，不会销毁，所以可以实现可读可写
return psl.a[pos];
}
int main()
{
SL s;
Init(s, 100);
push(s, 1);
push(s, 2);
push(s, 3);
push(s, 4);
for (int i = 0; i < 4; i++)
{
cout << s.a[i] << " ";
}
cout << endl;
for (int i = 0; i < 4; i++)
{
getElement(s, i) *= 2;
cout << s.a[i] << " ";
}
return 0;
}
5.7引用和指针的比较
语法：
1.引用不会再开辟空间，没有独立空间，和其引用实体共用同一块空间。指针会开辟空间，来存储变量的地址
2.引用不可以修改指向，指针可以
3.引用必须初始化，但是指针可以不初始化
4.没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
底层：
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
观察以下代码的汇编语言：
int main()
{
int a = 0;
int& b = a;
b = 20;
int* p = &a;
*p = 20;
return 0;
}
汇编语句：
可以观察到引用的底层是使用指针实现的。
6.内联函数
6.1概念语法：
语法：在函数前面加上inline即可
概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
inline int add(int x,int y)
{
return x + y;
}
//inline int add(int x, int y)
//{
// return x + y;
//}
int add(int x, int y)
{
return x + y;
}
int main()
{
int ret = add(1, 3);
return 0;
}
6.2特性
1.如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用。减少了函数栈帧的创建和销毁。
2.内联函数是一种以时间换空间的行为，如果代码比较大使用内联可能会使目标文件变大。
3.内联函数不能定义和声明分开。
会产生链接错误，内联函数被展开，就没有函数的地址，在链接过程中找不到。
4. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
使用前后对比：
没有使用内联函数：
使用内联函数：
从上面我们可以看出，并没有调用函数，而是将函数转化成指令，避免了建立函数栈帧。
6.3宏和内联的区别
宏：宏是在预处理阶段进行文本的替换，这样会有一些问题
优点：
1.在预处理阶段直接替换，提高性能
2.增强代码可读性
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查
4.宏不能
#define mul(x,y) x * y
//#define mul(x,y) (x) * (y)
#define square(x) x * x
int main()
{
//宏不能按值传递
int x = mul(1, 3);
//输出结果为3
int y = mul(2 + 3, 4);
//如果不加括号，输出结果为14，与我们预期的结果不同
//替换后结果：2 + 3 * 4 = 14
//期望结果：(2 + 3) * 4 = 20
//需要加括号
int a = 2;
int z = square(a++);
//期望的结果：a只自增一次 z = 2 * 2 = 4 , a =3
//替换后的结果: a自增了两次 (a++) * (a++) = 4 , a = 4
cout << a << endl; //输出4
cout << x << " " << y << " " << z << endl;
return 0;
}
在C++中我们可以使用以下来替代宏：
1.对于常量定义：const，enum
2.对于短小函数定义：inline
7.auto关键字（C++11）
auto可以用来实现类型的自动辨识。我们可以在类型比较复杂时使用，比如函数指针或者以后更复杂的情况使用。
void func(int x, int y)
{
}
int main()
{
auto x = 1;
void (*p) (int, int) = func;
auto m = func; //可以自动识别类型
return 0;
}
8.基于范围的for循环（C++11）
基于范围的for循环可以帮我们实现判断结束和自增，相比于以前的for循环可以更加方便，尤其在后期学习了容器等内容后，通过基于范围的for循环可以方便许多。
8.1语法：
for (数据类型 e : array)
{
}
array就是需要打印的数组，e就相当于一个中间变量，用来存储数组中的值。如果我们需要修改，则可以使用引用。
8.2实例：
int main()
{
int a[] = { 1,4,3,6,8,3,7 };
//原始方法打印
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
cout << a[i] << " ";
}
//1 4 3 6 8 3 7
cout << endl;
//基于范围的for循环
for (auto e : a)
{
cout << e << " ";
}
//1 4 3 6 8 3 7
cout << endl;
for (auto e : a)
{
e *= 2;
cout << e << " ";
}
//2 8 6 12 16 6 14
cout << endl;
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
cout << a[i] << " ";
}
//1 4 3 6 8 3 7
cout << endl;
//加上引用就可以修改数组的值
for (auto& e : a)
{
e *= 2;
cout << e << " ";
}
//2 8 6 12 16 6 14
cout << endl;
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
cout << a[i] << " ";
}
//2 8 6 12 16 6 14
return 0;
}
9.指针控制nullptr（C++11）
在C++中，对于NULL的定义为0，而不是指针，通过以下打印结果可以得出。
void func(int x)
{
cout << "func(int x)" << endl;
}
void func(int* p)
{
cout << "func(int* p)" << endl;
}
int main()
{
func(1);
func(0);
func(NULL);
func(nullptr);
return 0;
}
输出结果如下：
func(int x)
func(int x)
func(int x)
func(int* p)
以上就是本次所有内容，谢谢观看。
