C++入门精要-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46107667/article/details/117994599

C++入门

初识C++

什么是C++

C++关键字

命名空间

C++输入和输出

缺省参数

函数重载

引用

内联函数

auto关键字

基于范围的for循环

指针空值——nullptr

1.1什么是C++
**C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。**为了解决软件危机， 20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
2. C++关键字
C++总计63个关键字，C语言32个关键字

3.命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
3.1命名空间定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。{}中可以定义变量也可以定义函数。

//c++版的 hello world
#include<iostream>
using namespace std:
 int main()
 {
	cout<<"hello world!"<<endl; 
 	return 0;
 }

这里的namespace就是命名空间，也是C++一个关键字。后面的std就是这个空间的名字（域）。
namespace 定义的是一个域，主要解决的是命名冲突的问题。
例如：c语言中的某些程序

#include<stdio.h>
int main()
{
	int scanf=10;
	int strlen=20;
	scanf("%d",&scanf);//这里就会出现错误，因为命名冲突。
}

命名空间还可以嵌套命名空间，嵌套隔离

//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;
       }
   }
}

还可以同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。类似于就像是调用不同函数一样。
3.2命名空间的使用

#include<iostream>
using namespace std:
 int main()
 {
	cout<<"hello world!"<<endl; 
 	return 0;
 }

C++库为了防止命名冲突，把自己库里面的东西都定义在一个std的命名空间中。
要使用标准库的东西，有三种方式
1.指定命名空间
缺点：麻烦，使用的时候，需要在每个地方指定，但是是最规范的方式。

#include<iostream>
//using namespace std:
 int main()
 {
	std::cout<<"hello world!"<<std::endl; //指定命名空间
 	return 0;
 }

2.把std整个展开，相当于库里面的所有东西都到全局域中
缺点:如果我们自己定义的东西和库冲突了就没办法解决。

#include<iostream>
using namespace std:
 int main()
 {
	cout<<"hello world!"<<endl; 
 	return 0;
 }

3.对部分常用库里面的进行展开

#include<iostream>
//using namespace std:
using std::cout;
using std::endl;
 int main()
 {
	cout<<"hello world!"<<endl; 
 	return 0;
 }

4.C++输入和输出

使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用 +std的方式。
使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c
cout cin 相比于c语言中的printf scanf的区别是什么？
cout cin可以自动识别类型。（原理：函数重载，运算符重载）
5.缺省参数（给定默认值）
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

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

int main()
{
    TestFunc();     // 没有传参时，使用参数的默认值 
    TestFunc(10);   // 传参时，使用指定的实参
}

5.1缺省参数分类
全缺省参数

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

半缺省参数

半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现

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

注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。最好就是声明给缺省值，定义时不给
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

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

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

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

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

int main()
{
    Add(10, 20); 
    Add(10.0, 20.0); 
    Add(10L, 20L);

    return 0;
}

7.引用（取别名）——类似于指针
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

//b就是a的别名，b是a的引用
void TestRef()
{
   int a = 10;
   int& b = a;//<====定义引用类型

   printf("%p\n", &a); 
   printf("%p\n", &b);
}

引用的特性

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

void TestConstRef()
{
   const int a = 10;
   //int& ra = a;   // 该语句编译时会出错，a为常量 （因为权限被放大）
   const int& ra = a;//这样就可以，变成const int 引用
   // int& b = 10;  // 该语句编译时会出错，b为常量 
   const int& b = 10;
   double d = 12.34;
   //int& rd = d;  // 该语句编译时会出错，类型不同 
   const int& rd = d;
   int b=10;//（可读可写）
   int &rb=b;
   const int&crb=b;//crb引用b属于权限缩小，可以引用（只读）
}

引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际有空间的，因为引用是按照指针方式来实现的
引用和指针的不同点
1.引用在定义是必须初始化，指针没有要求
2.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个类型实体
3.没有NULL引用，但是有NULL指针
4.在sizeof中含义不同：引用结构为引用类型的大小，但是指针始终是地址空间所占字节个数（32位平台下占4个字节，64位平台下占用8个字节）
5**.引用自加即引用实体增加1，指针自加即指针向后偏移一个类型的大小**
6.有多级指针，但没有多级引用
7.访问实体方式不同，指针需要显示解引用，引用编译器自己处理
8.引用比指针使用起来相对更加安全

8.内联函数
对于频繁调用的小函数，定义成inline，会在调用地方展开，没有栈帧开销。
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
内联函数的特性：
1.inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2.inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
宏函数：

#define add(x,y) ((x)+(y))

宏函数的优缺点：
优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易无用
3.没有类型安全的检查

9.auto关键字
auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
auto的使用细则

auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto不能推导的场景
auto不能作为函数的参数
2.auto不能直接用来声明数组

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

10.基于范围的for循环
范围for的使用条件：

for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
    for(auto& e : array) 
        cout<< e <<endl;
}

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

11. 指针空值nullptr(C++11)
指针空值的使用：

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。