C++学习第一天（入门学习）

1、命名空间

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的

#include<stdio.h>
#include<stdlib.h>

int rand = 10;

int main()
{
	printf("%d\n", rand);
	return 0;
}
//error:  rand:重定义,以前的定义是“函数”

命名空间定义

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

//1.正常的命名空间定义
namespace bit
{
	//命名空间中可以重新定义变量、函数、类型
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

//2、命名空间可以嵌套
namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

//3、同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中
//比如我在test.h上写一个同样的namespace，最后会和test.cpp的合成一个namespace

命名空间使用

命名空间中成员该如何使用，有三种方式
第一种：加命名空间名称及作用域限定符

int main()
{
	printf("%d\n", N::a);
	return 0;
}

第二种：使用using将命名空间中的某个成员

using N::b;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", b);
	return 0;
}

第三种：using namespace N;

using namespace N;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", b);
    Add(10,20);
	return 0;
}

2、C++输入和输出

用c++的方式写hello world是怎么样写的呢？

#include<iostream>
//std是C++标准库的命名空间名，C++的标准库的定义实现都放在这个命名空间中
using namespace std;

int main()
{
	cout << "hello world" << endl;
	return 0;
}

我们需要注意几点：

1、使用cout标准输出对象（控制台）和cin标准输入对象（键盘）时，必须包含<iostream>头文件以及按命名空间使用方法使用std
2、cout和cin是全局的流对象，endl是特殊的C++符号，和\n的效果等同
3、<<是流插入运算符，>>是流提取运算符
4、使用C++输入输出更方便

4、缺省参数

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

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

int main()
{
	Func();
	Func(10);
	return 0;
}

关于缺省参数的分类：

全缺参数：

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

半缺省参数：

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

需要注意的是：半缺省参数必须从右往左依次来给出，不能间隔着给。并且缺省参数在函数声明和定义中不能同时出现。如果声明和定义同时出现，值又不同，编译器就不能确定选取哪个值了，缺省值必须是常量或者是全局变量

5、函数重载

概念：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数或类型或类型顺序）不同，用来处理实现功能类似的数据类型不同的问题

#include<iostream>
using namespace std;

//参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

//参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}

//参数类型顺序不同
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;
}

6、引用

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

例如：

void test()
{
	int a = 20;
	int& ra = a;//定义引用类型
	printf("%p\n", &a);
	printf("%p\n", &ra);
}

需要注意的是：引用在定义时必须初始化，一个变量可以有多个引用，引用一旦引用一个实体，再不能引用其他实体

关于常引用

void test()
{
	const int a = 10;
	//int& ra = a;//error
	const int& ra = a;
	//int& b = 10;//error
	const int& b = 10;
	double d = 3.14;
	//int& rd = d; //error 类型不同
	const int& rd = d;
}

使用的场景

1、做参数

void swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

2、做返回值

int& count()
{
	static int n = 0;
	n++;
	return n;
}

需要注意的是，如果函数返回时，出了函数作用域，如果返回对象还在，则可以使用引用返回，如果已经返还给系统了，则必须使用传值返回。并且发现，传值和指针指针的效率会高很多

引用和指针的区别

在语法上面引用就是一个别名，没有独立空间，和引用实体共用一块空间

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

总之，不同之处有以下9点：
1、引用概念上定义一个变量的别名，指针存储一个变量的地址
2、引用在定义时必须初始化，指针没有要求
3、引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型的实体
4、没有NULL引用。但是指针是有NULL的
5、sizeof的含义不相同：引用的结果是引用类型的大小，指针是地址空间所占字节个数
6、引用自加即引用的实体增加一，指针自加是指针向后偏移一个类型的大小
7、有多级指针但是没有多级引用
8、访问实体方式不同，指针需要解引用，引用是编译器自己处理
9、引用比指针更加的安全

7、内联函数

概念：用inline修饰的函数叫做内联函数，编译时会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，提升运算效率

需要注意的是：内联函数使用时不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数的地址了，链接就会找不到

问：宏的优缺点？

优点：增强代码的复用性  提高性能

缺点： 不方便调试 代码的可读性差 没有类型安全的检查

8、auto关键字

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

auto的使用细则

auto与指针联合起来使用

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

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	return 0;
}

在同一行定义多个变量

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

需要注意的是：auto不能作为函数的参数  auto不能直接来声明数组 

9、基于范围的for循环

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

void test()
{
	int a[] = { 1,2,3,4,5 };
	for (auto& e : a)
		e *= 2;
	for (auto e : a)
		cout << e << " ";
}

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

10、指针空值nullptr

需要注意的是：

1、在使用nullptr表示指针空值，不需要包含头文件
2、在C++11中，sizeof（nullptr）和sizeof（（void*）0）所占的字节数相同
3、以后建议使用nullptr不建议使用NULL