C++初阶 入门

目录

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

命名空间

C++输入输出

缺省参数

函数重载

引用

内联函数

auto关键字(C++11)

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

指针空值nullptr(C++11)

C++类与对象(上)

C++类与对象(中)

---

 

C++(98) :1998年，C++的ANSI/IS0标准被投入使用。通常，这个版本的C++被认为是标准C++。所有的主流C++编译器都支持这个版本的C++

C++(11) : C++11标准为C++编程语言的第三个官方标准 , 于2011年8月12日公布  ，并于2011年9月出版 . 此次标准C++98发布后13年来第一次重大修正。各大主流编译器产商也逐步添加了对C++11语法的支持

---

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

---

命名空间

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

 命名空间定义:

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{ }即可，{ }中即为命名空间的成员。

注 : 一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

//1. 普通的命名空间
namespace N1 { // N1为命名空间的名称
// 命名空间中的内容，既可以定义变量，也可以定义函数
    int a;
    int Add(int left, int right) {
        return left + right;
    }
}
//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. 同一个工程中允许存在多个相同名称的命名空间
// 编译器最后会合成同一个命名空间中。
namespace N1 {
    int Mul(int left, int right) {
        return left * right;
    }
}

命名空间的使用:

就拿上面的命名空间N2为例 

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() {
    printf("%d\n", N2::a);
    printf("%d\n", N2::N3::c);
    return 0;
}

• 使用using关键字将命名空间中成员引入(单个对外可见)

using N2::b;
using N2::N3::c
int main() {
    printf("%d\n", b);
    printf("%d\n", c);
    return 0;
}

• 使用using namespace 命名空间名称引入(全部对外可见)

using namespace N2;
int main() {
    printf("%d\n", a);
    printf("%d\n", N3::c);
    return 0;
}

注 : 函数的使用也如此 . 

---

C++输入输出

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

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

#include <iostream>
using namespace std;
int main() {
    int a;
    double b;
    char c;
    cin>>a;
    cin>>b>>c;
    cout<<a<<endl;
    cout<<b<<" "<<c<<endl;
    return 0;
}

---

缺省参数

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

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

缺省参数分类 : 

• 全缺省参数

函数参数都有缺省值

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

• 注意

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

---

函数重载

函数重载:是函数的一种特殊情况，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;
}

 注意 : 参数列表完全相同, 返回值不同的 ,不能算是函数重载

例如 :

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

• 名字修饰

说到C++中的函数重载 , 就不得不提名字修饰

C/C++程序要运行, 需要经历以下几个阶段：预处理、编译、汇编、链接。

名字修饰 是一种在编译过程中，将函数、变量的名称重新改编的机制，简单来说就是编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称。

C语言的名字修饰规则非常简单，只是在函数名字前面添加了下划线" _ "。比如，对于以下代码，在最后链接时就会出错：

.c文件

#include<stdio.h>
int Add(int a, int b);
int main() {
    Add(1, 2);
    return 0;
}

在链接时编译器会报出以下错误 :

上述Add函数只给了声明没有给定义，在main函数中引用的Add函数找不到函数体, 因此在链接时就会报错 .

从报错结果中可以看到，C语言只是简单的在函数名前添加下划线。因此当工程中存在相同函数名的函数时，就会产生冲突。

那么C++中支持函数重载 , 命名空间 . 也就意味着C++中有着与C不同的更加复杂的函数名修饰方式 .  需要注意的是不同系统, 不同编译器在底层实现的方式不尽相同 , 本文内容都是VS2017中测试的
我们来看这段代码 : 
.cpp文件

#include<iostream>
using namespace std;
int Add(int a, int b);
double Add(double a, double b);
int main() {
	Add(1, 2);
	Add(1.1, 2.2);
	system("pause");
	return 0;
}

我们看到在链接时出错, 也是只声明 , 未定义, 在链接时找不到函数实体, 所以报错 .
重点是编译器在底层使用的不是Add名字，而是被重新修饰过的一个比较复杂的名字，被重新修饰后的名字中包含了：函数的名字以及参数类型。这就是为什么函数重载中几个同名函数要求其参数列表不同的原因。只要参数列表不同，编译器在编译时通过对函数名字进行重新修饰，将参数类型包含在最终的名字中，就可保证名字在底层的全局唯一性。

实际不止有名字和参数类型还有作用域和返回值, 名字修饰的准确映射机制为 : 作用域+返回类型+函数名+参数列表

• extern “C”

C++为了与C保持兼容 , 在C++的工程中可能有些代码需要按照C的分格来编写 , 此时extern"C" 就派上了用场 . 
extern"C"可以加在函数之前, 也可以将一段代码包起来, 例如 : 

extern"C" int Add(int a, int b);
int Add(int a, int b) {
	return a + b;
}
extern"C" {
	int Add2(int a, int b) {
		return a + b;
	}
}

需要注意的是 在编写C风格的函数时, 必须在声明时加上extern"C", 不能出现函数声明时无extern"C", 函数实现时有extern"C"

---

引用

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

类型& 引用变量名 = 引用实体;
.cpp文件

#include<iostream>
using namespace std;

int main() {
	int a = 10;
	int& ra1 = a;
	int& ra2 = a;
	int& rra = ra1;
	cout << a << endl;
	cout << ra1 << endl;
	cout << ra2 << endl;
	cout << rra << endl;
	ra1 = ra2 + rra;
	cout << a << endl;
	cout << ra1 << endl;
	cout << ra2 << endl;
	cout << rra << endl << endl;
	cout << &a << endl;
	cout << &ra1 << endl;
	cout << &ra2 << endl;
	cout << &rra << endl;
	system("pause");
	return 0;
}

可以看出引用没有占用新的空间, 与引用实体共用一块内存空间

引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体
4. 引用类型必须和引用实体是同种类型的

常引用

.cpp文件

#include<iostream>
using namespace std;

int main() {
	const int a = 10;
	//int& ra = a; // 该语句编译时会出错，a为const int, 引用类型和引用实体类型不同
	const int& ra = a;

	//int& b = 10; // 该语句编译时会出错，b为const int, 引用类型和引用实体类型不同
	const int& b = 10;

	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，d为double, 引用类型和引用实体类型不同
	const int& rd = d;
	cout << &rd << endl;
	cout << &d << endl;
	cout << rd << endl;
	cout << d;
	system("pause");
	return 0;
}

值得注意的是double d =12.34;  const int& rd = d; 出现这种情况时会给引用一个临时的空间

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但指针有自己独立的空间, 指针存放的是所指变量的地址

#include<iostream>
using namespace std;

int main() {	
    int a = 10;
    int& ra = a;
    int* pa = &a;
    cout << "a的地址:" << &a << endl;
    cout << "ra的地址:" << &ra << endl;
    cout << "pa的地址:" << &pa << endl;
    system("pause");
    return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

#include<iostream>
using namespace std;
int main() {
    int a = 10;
    int& ra = a;
    ra = 20;
    int* pa = &a;
    *pa = 20;
    system("pause");
    return 0;
}

我们来看看这段代码的汇编

我们可以看出在汇编代码上两者完全相同, 所以引用的底层实现就是指针 . 

引用和指针的不同点:

1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全(没有野引用,空引用, 改变不了指向 )

使用场景

1. 做参数

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

2.做返回值

int& TestRefReturn(int& a) {
    a += 10;
    return a;
}

既然可以做参数和返回值, 那么我们是否可以随意使用呢 ? 来看下面的代码 :
.cpp文件

#include<iostream>
using namespace std;
int& Add(int a, int b) {
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	system("pause");
	return 0;
}

本该是1+2 的结果 3 , 却变成了 3+4 的结果 7 
这是因为在第一次调用Add函数结束后给Add函数分配的栈空间已经被释放回收, 当然函数内的局部变量c也难逃被释放的命运, 但函数Add却返回了c的引用, 让ret也成为了c的引用(即获得了已经被释放的c变量的地址) , 当系统再次调用Add函数, 重新给Add函数分配栈空间时, 因为两次调用之间没有其他出入栈的操作 ,  Add函数又被分配到了第一次调用Add时分配的栈空间, 此时c变量也分配到了与第一回调用Add时相同的内存空间 , 值被修改为 7 , 函数调用结束, 空间再被释放回收, 但ret还是这块内存空间(曾经是c,现在已经非法的内存空间)的引用(或者说是指向这片内存空间) , 所以 如这块空间没被再利用的话, 这块内存空间的值就为7 , 但也有可能这片空间会被再回收利用或者两次Add调用之间再有其他的进出栈操作, 这个值可能就不再是 7 了

---

内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会判断是否将此函数作为内联函数使用 , 如果以内联函数使用 , 编译器会在调用内联函数的地方展开, 没有函数压栈的开销，内联函数提升程序运行的效率。如果判断不是以内联函数使用, 则会当做普通函数处理 .

所以说, inline 这个关键字只是我们对编译器的建议, 并不像其他关键字一样, 是死命令

扩展 : 在C/C++中还有一个建议性质的关键字 , register 建议将变量分配到寄存器中, 以加快运行速度, 在C中这种变量不能取地址 , 但在C++中如果我们显式取了register变量的地址，编译器一定会将这个变量定义在内存中，而不会定义为寄存器变量。

内联函数的特点 : 

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等比较复杂时，编译器优化时会忽略掉内联, 将其定义为普通函数。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

类函数宏与内联函数

#define的基本语法非常简单, 但完全不影响它的强大不过有时候正因为宏(#define)的简单、方便和强大，就会导致我们平常在使用的时候，其中会有很多的注意点和细节需要我们去注意，如果不小心将其忽略, 那么可能会带来我们意料之外的不想要的结果。推荐用宏但不能滥用 . 

类函数宏有以下缺点 : 
1.宏是不方便调试的。 
2. 宏由于类型无关，也就不够严谨。
3. 宏可能会带来运算符优先级的问题，导致程容易出现错。

其中内联函数是在编译时展开(或不处理为内联函数), 类函数宏在预处理阶段展开

我们可以用内联函数来代替类函数宏, 很好的解决以上缺点 . 

---

auto关键字(C++11)

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它 .
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

auto的使用细则

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

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

1. auto与指针和引用结合起来使用
    用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

#include<iostream>
using namespace std;
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;
    cout << x << endl;
    *b = 30;
    cout << x << endl;
    c = 40;
    cout << x << endl;
    system("pause");
    return 0;
}

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

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

 

auto不能推导的场景

1. auto不能作为函数的参数

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

3. auto不能定义类的非静态成员变量

4. 实例化模板时不能使用auto作为模板参数

---

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

在C++98中如果要遍历一个数组，可以按照以下方式进行 :

#include<iostream>
using namespace std;
int main() {
	int a[] = { 1,2,3,4,5,6,7,8,9,10 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i) {
		cout << a[i] << "  ";
		//cout << *(a + i);//两种写法(两种解引用的写法, 本质相同)
	}
	cout << endl;
	for (int* p = a; p < a + sizeof(a) / sizeof(a[0]); ++p) {
		cout << *p << "  ";
	}
	cout << endl;
	system("pause");
	return 0;
}

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

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

#include<iostream>
using namespace std;
int main() {
	int a[] = { 1,2,3,4,5,6,7,8,9,10 };
	for (auto i : a) {
		cout << i << "  ";
	}
	cout << endl;
	system("pause");
	return 0;
}

范围for的使用条件

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

主要用来遍历数组和有begin, end和有++迭代器的容器(包括我们自己写的容器) .

注意：以下代码就有问题，因为for的范围不确定

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

 

---

指针空值nullptr(C++11)

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

int* p1 = NULL;
int* p2 = 0;
// ……

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
 

#include<iostream>
using namespace std;
void f(int) {
	cout << "f(int)" << endl;
}
void f(int*) {
	cout << "f(int*)" << endl;
}
int main() {
	f(0);
	f(NULL);
	f((int*)NULL);
	system("pause");
	return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于(NULL)被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

nullptr 与 nullptr_t 

为了考虑兼容性，C++11并没有消除常量0的二义性，C++11给出了全新的nullptr表示空值指针。那么C++11为什么不在NULL的基础上进行扩展，这是因为NULL以前就是一个宏，而且不同的编译器厂商对于NULL的实现可能不太相同，而且直接扩展NULL，可能会影响以前旧的程序。因此：为了避免混淆，C++11提供了nullptr，
即：nullptr代表一个指针空值常量。nullptr是有类型的，其类型为nullptr_t，仅仅可以被隐式转化为指针类型，nullptr_t被定义在头文件中：

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