【C++】入门学习

1.命名空间

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

int rand = 10;
//命名冲突，我们和库


int main()
{
	printf("%p ", rand);
	return 0;
}

在C语言中 stdlib.h  库中有关于rand的定义，导致命名冲突

为了解决这个问题，我们可以使用命名空间 namespace 

namespace name
{
	int rand = 10;
}

但是此时打印rand，我们看到的结果是

这里就要说到我们的默认查找顺序 

当前局部  ->  全局，默认情况下不会去命名空间

引入了相应命名空间以后的默认查找顺序

当前局部区域  -> 全局  +  展开的命名空间（展开的命名空间相当于把命名空间的内容放到全局）

所以如果我们想要得到命名空间的rand，可以 写  name:: rand(：：前没有名字，默认为访问全局变量)

1.命名空间的使用

• 加命名空间名称及作用域限定符

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

• 使用using将命名空间中某个成员引入

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

• 使用using namespace命名空间名称引入

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

2.命名空间定义函数和结构体

• 函数

//定义函数
namespace  a
{
	int Add(int x, int y)
	{
		return x + y;
	}
}

namespace b
{
	int Add(int m, int n)
	{
		return m + n + 1;
	}
}
int main()
{
	printf("%d\n", a::Add(1, 2));
	printf("%d\n", b::Add(1, 2));
	return 0;
}

• 结构体

namespace fz
{
	struct Node
	{
		int val;
		struct Node* next;
	};
}
int main()
{
	struct fz::Node Pnode;
	return 0;
}

3.命名空间的嵌套

//命名空间的嵌套
namespace fz
{
	namespace a
	{
		int rand = 10;
	}
}

int main()
{
	printf("%d ", fz::a::rand);
	return 0;
}

2.C++的输入输出

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

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

1. 使用cout标准输出对象（控制台）和cin标准输入对象（键盘）时，必须包含<iostream>头文件，以及按照命名空间使用方法使用std.
2. cout和cin都是全局的流对象，endl是特殊的C++符号，表示换行输出，它们都包含在<iostream>头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. C++的输入输出可以自动识别变量类型

3.缺省参数

1.缺省参数概念

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

void f(int a = 3)
{
	cout << a << endl;
}

int main()
{

	f();//没有参数，使用参数默认值
	f(2);

	return 0;
}

2.分类

• 全缺省参数

void Add(int x=11, int y = 10, int z = 9)
{
	cout << x << endl;
	cout << y << endl;
	cout << z << endl;
}

int main()
{
	Add(12, 3, 3);
	Add(2);
	return 0;
}

• 半缺省参数

void Add(int x, int y = 10, int z = 9)//必须是没有默认值的在左边，有的放右边,不能间隔
{
	cout << x << endl;
	cout << y << endl;
	cout << z << endl;
}

int main()
{
	Add(12, 3, 3);
	Add(2);
	return 0;
}

注意：

1. 半缺省参数必须从右到左依次给出，不能间隔
2. 不能在函数定义和声明中同时给
3. 缺省值必须是常量或全局变量
4. C语言不支持

4.函数重载

C++允许同一作用域声明几个功能相似的同名函数，常用来实现功能相似的数据类型不同的问题

1.参数类型不同

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


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

2.参数个数不同

void f()
{
	cout << "f()" << endl;
}


void f(int a)
{
	cout << "f(int a)" << endl;
}

3.参数类型顺序不同

void f1(int a, char b)
{
	cout << a << "	" << b << endl;
}

void f1(char a, int b)
{
	cout << a << "	" << b << endl;
}

C语言不支持重载

5.引用

1.概念

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

2.引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，不能再引用其他实体
4. 没有多重引用
5. sizeof(int)==sizeof(int&),引用以引用类型大小为准
6. 引用不能完全替代指针，比如链表的实现

3.常引用

权限可以平移/缩小，不能放大

1.常量

const int a = 8;
int& b = a;//权限放大

可以改为

const int a = 8;
const int& b = a;

2.指针

const int m = 0;
int p = m;

const int* p1 = &m;
p1++;//p1可以改变

int* p2 = p1;//权限放大

可以改为

const int* p1 = &m;
p1++;//p1可以改变

const int* p2 = p1;

3.临时变量

double d = 12.34;
int i = d;//类型转换产生临时变量，临时变量具有常性
const int& r = d;//d转换成int类型产生临时变量，具有常性
double& d1 = d;

int x = 0, y = 1;
const int& r2 = x + y;//x+y 表达式运算产生临时变量，具有常性，应该加const

 4.NULL的引用

int* p = NULL;
int& r = *p;//这里没有解引用，这里底层只是把指针地址存起来，所以不会报错
//cout << r << endl;这里才会报错

4.使用场景

1.做参数

void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

2.做返回值

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

6.内联函数

1.概念

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

2.特性

1.内联函数是一种空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

2.inline对于编译器只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小，不是递归，且频繁调用的函数用inline修饰，否则编译器会忽略inline特性

tip:内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求

一般来说，内联机制用于优化规模较小，流程直接，频繁调用的函数，很多编译器。很多编译器都不支持内联递归函数，而且一个75行的函数也不大可能在调用点内联地展开。

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

7.auto关键字

使用auto修饰地变量，是具有自动存储器的局部变量

auto a=4;  相当于  int a=4;

1.auto使用细则

auto与指针和引用结合使用

int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;

用auto和auto*没有区别

但是auto声明引用类型的时候必须加&

2.auto不能推导的场景

1.auto不能作为函数参数

void f(auto x){}

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

auto a[]={0,1,2};

8.基于范围的for循环

对于一个有范围的集合，由程序员来说明循环的范围是多余的，有时候还会容易犯错误，所以C++引入了基于范围的for循环。

for循环后的括号由冒号" :  "分成两部分，第一个部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{

	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (auto e : a)
	{
		cout << e << " ";
	}

	return 0;
}

范围for的使用条件：

• 循环迭代的范围必须是确定的
• 迭代的对象要实现++和==的操作

9.指针空值nullptr

NULL其实是一个宏，NULL可能被定义为0，或者被定义为无类型指针的常量,但是默认情况下编译器将其看作一个常量，如果需要其按照指针方式来使用，必须对其进行强制类型转换。

void f(int)
{
	cout << "f(int)" << endl;

}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);
    f((int*)NULL);
	f(nullptr);
	return 0;
}

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为它是关键字
2. 在C++11中，sizeof(nullptr)  和 sizeof((void*)0)所占字节相同
3. 后续表示指针空值最好使用nullptr