＜C++ 初阶＞ C++入门

目录

什么是C++

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

2.命名空间

2.1命名空间定义

3.C++输入&输出

4.缺省参数

4.1缺省参数概念

4.2缺省参数的分类

4.2.1全缺省参数

4.2.2半缺省参数

5.函数重载

内容较多，新开一篇文章

6.引用

6.1引用概念

6.2引用特性

6.3常引用

6.4使用场景

1.作参数(输出型参数，减少拷贝、提高效率)

2.作返回值        

7.内联函数

7.1概念

7.2特性

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

8.1概念

8.2auto使用细则

8.3auto不能推导的场景

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

9.1范围for的语法

9.2范围for的使用条件

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

10.1C++98中的指针空值

---

什么是C++

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言就不适合了。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming：面对对象)思想，支持面向对象的程序设计语言诞生。

1982年，Bjarne stroustrup博士在C语言的基础上引入并扩充了面对对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。C++是基于C语言而产生的，它既可以进行C语言的过程化设计，又可以进行以抽象类型为特点的基于对象的程序设计，还可以进行面对对象的程序设计。

C++标准(C++98 C++11 C++20)

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

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

2.命名空间

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

2.1命名空间定义

//命名空间是定义的全局变量，将全局变量中的冲突隔离开来，生命周期不变
//不能定义局部
namespace byte1 //byte1为命名空间的名称
{
	//1.命名空间中可以定义变量、函数、类型
	int a;

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

    struct ListNode
    {
        int data;
        struct ListNode* next;
    }
}

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

	namespace byte3
	{
		int c;
		int d;
		int Sub(int x, int y)
		{
			return x - y;
		}
         struct BTreeNode
        {
            int data;
            struct BTreeNode* left;
            struct BTreeNode* right;
        }
	}
}

//3.同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成为同一个命名空间。


//展开命名空间——不能随便用
using namespace byte1::a;//只放a出来
using namespace byte2;
using namespace byte3;

int main()
{
    struct byte2::byte3::BTreeNode n1;
    struct byte3::BTreeNode n2;//using namespace byte2;
    struct BTreeNode n3;//using namespace byte2; using namespace byte3;

    return 0;
}


#include 
using namespace std;// std 是封C++库的命名空间

int main()
{
    cout << "Hello World!" << endl;
    std::cout << "Hello World!" << std::endl; //不加using namespace std;

    return 0;
}

命名空间的三种使用方式：

加命名空间名称及作用域限定符        (使用：：) 全不放。

使用using将命名空间中成员引入     (将指定命名空间中成员放出来) 部分放。

使用usingspace命名空间名称引入   (将整个命名空间放出来) 全放。

.

3.C++输入&输出

#include 
using namespace std;

int main()
{
    //   << 流插入运算符   >> 流提取运算符
    cout << "Hello World!" << endl;

    return 0;
}

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

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

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

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

4.缺省参数

4.1缺省参数概念

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

//         缺省参数/默认参数
void TestFunc(int a = 0)
{
	cout << a << endl;	
}

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

	return 0;
}

4.2缺省参数的分类

4.2.1全缺省参数

void TestFunc(int a = 1, int b = 2, int c = 3)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

4.2.2半缺省参数

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

注意：

1.半缺省参数必须从右往左依次来给出， 不能间隔着给

2.缺省参数不能在函数声明和定义中同时出现

//.h
void TestFunc(int a = 1);

//.c
void TestFunc(int a = 2);
{}

//如果声明与定义位置同时出现，恰巧两个位置提供的缺省值不同，
//那么编译器就无法确定到底该用哪个缺省值。

3.缺省值必须是常量，或者全局变量

4.C语言不支持(编译器不支持)

5.函数重载

内容较多，新开一篇文章

链接：http://t.csdn.cn/q7awX

6.引用

6.1引用概念

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

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

#include 
using namespace std;

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 1;
	int b = 2;
	Swap(a, b);
	
	cout << a << " " << b << endl;

	return 0;
}

#include 
using namespace std;

typedef struct ListNode
{
	int data;
	struct ListNode* next;
}LTNode, *PLTNode;

void LTPushBack_C(LTNode** pphead, int x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (*pphead == NULL)
		*pphead = newnode;
}

void LTPushBack_CPP(PLTNode& phead, int x);
void LTPushBack_CPP(LTNode*& phead, int x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (phead == NULL)
		phead = newnode;
}

int main()
{
	LTNode* plist = NULL;
	LTPushBack_C(&plist, 1);
	LTPushBack_CPP(plist, 1);

	return 0;
}

注意：引用类型必须和引用实体是同种类型的

6.2引用特性

1.引用在定义时必须初始化

2.一个变量可以有多个引用

3.引用一旦引用一个实体，就不能引用其它实体

void TestRef()
{
    int a = 1;

    int& ra; //引用定义时没有初始化，编译出错

    int& ra = a;
    int& rra = a;
    printf("%p %p %p\n", &a, &ra, &rra);    
}

6.3常引用

void TestConstRef()
{
    //对原引用变量，权限只能缩小，不能放大
    const int a = 1;
    int& ra = a; // a为常量，直接引用会编译出错
    const int& ra = a;

    int& b = 2; // 2为常量，直接引用会编译出错
    const int& b = 2;
    
    double c = 3.14;
    int& rc = c; // 引用类型与实体类型不同，编译出错
    //在进行类型转换的时候，赋值给的是临时变量
    //rc引用c的临时变量，rc的改变会导致临时变量的改变，临时变量具有常性不可改变，所以要加上const

    const int& rc = c;
}

、

6.4使用场景

1.作参数(输出型参数，减少拷贝、提高效率)

void Swap(int& x, int& y)
{
    int tmp = x;
    x = y;
    y = x;
}

2.作返回值        

int& Count()
{
    static int n = 0;
    while(n < 1)
    {
        n++;
    }
    
    return n;
}

int main()
{
    int& ret = count();
    cout << ret << endl; // 输出结果可能为1，也可能为随机值  访问野指针！ 越界
    return 0;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。 

传值、传引用效率比较

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

引用与指针的不同：

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

2.引用在定义是必须初始化，指针没有要求。

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

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

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

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

7.有多级指针，没有多级引用。

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

9.引用比指针使用起来相对安全。

7.内联函数

7.1概念

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

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

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

7.2特性

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

2.inline对于编译器只是一个建议，编译器会自动优化，如果定义为inline的函数很长或者是递归函数等等，编译器优化时会自动忽略掉内联。

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

宏的优缺点        

优点：

1.增强代码的复用性

2.提高性能

缺点：

1.不方便调试。（因为与编译阶段进行了替换）

2.导致代码可读性差，可维护性差，容易误用。

3.没有类型安全检查。

C++代替宏的技术

1.常量定义 换用const enum

2.短小函数定义 换用内联函数

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

8.1概念

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

C++11中，标准委员会赋予了 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替换为变量实际的类型。

8.2auto使用细则

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

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

int main()
{
    int x = 1;
    auto a = &x;
    auto* b = &x;
    auto& c = x;

    return 0;    
}

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

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

void TestAuto()
{
    auto a = 1, b = 2;
    auto c = 3.14, d = 4; //该行代码会编译失败，因为c和d的初始化表达式类型不同
}

8.3auto不能推导的场景

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

//编译失败，auto不能作为参数类型，编译器无法对a的实际类型进行推导    
void TestAuto(auto a)
{}

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

//error
void TestAuto
{
    int a[] = {1, 2, 3};
    auto b[] = {4, 5, 6};
}

3.为了与避免C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。

4.auto在实际中最常见的优势就是跟C++11提供的新式for循环和lambda表达式等进行配合使用。

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

9.1范围for的语法

在C++98中如果要遍历一个数组，可通过以下方式进行：

void TestFor()
{
    int a[] = {1, 2, 3};
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
        a[i] = 0;
    
    for(int* p = a; p < a + sizeof(a) / sizeof(a[0]); p++)
        cout << *p << endl;
}

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

void TestFor()
{
    int a = {1, 2, 3};
    for(auto e : a)
        cout << e << " ";

    for(auto& e : a)
        e /= 2;
    
    return 0;
}

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

9.2范围for的使用条件

1.for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

//编译不通过，此处a为指针而不是数组，无法知到数组a的范围
void TestFor(int a[])
{
    for(auto&e : a)
        cout << e << endl;
}

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

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

10.1C++98中的指针空值

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

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
}

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

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

在C++中                                NULL = 0     nullptr = （(void*)0）

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，因此调用了f(int)函数。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型指针(void*)的常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针的方式来使用，必须将其强制类型转换为(void*)0。

注意：

1.在使用nullptr表示指针空值时，不需要包含头文件，nullptr是C++11作为关键字引入。

2.在C++11中，sizeof(nullptr)与sizeof((void*)0)所占字节数相同。

3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。