C++入门基础

一、简单的认识一下C++

在.cpp的文件下，C语言实现的hello world依旧可以运行，C++兼容C语言绝大多数的语法

C++版本的hello world应该是这样写的：

二、namespace（命名空间）

1.namespace的价值

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

#include <stdio.h>
#include <stdlib.h>//不包含这个头文件时不会报错（包含了rand（）函数）
int rand = 10;
int main()
{
	// 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
	printf("%d\n", rand);
	return 0;
}

2.namespace的定义

• 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可（注意不用在括号后面加；），{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
• namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。
• C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期。
• namespace只能定义在全局，当然他还可以嵌套定义。
• 当多文件中定义的同名namespace会被认为是⼀个namespace，不会冲突。
• C++标准库都放在⼀个叫std(standard)的命名空间中

(::域作用限定符) 

//域
namespace bit
{
	int rand = 10;
}
int a = 20;

int main()
{
	// ::域作用限定符
    int a=10;
	printf("%d\n", bit::rand);//10
	printf("%d\n", ::a);//20   //未指定域名，默认访问全局域

	return 0;
}

(1)正常的命名空间定义

namespace bit
{
	int rand = 10;

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

	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{

	// 这⾥默认是访问的是全局的rand函数指针
	printf("%p\n", rand);

	// 这⾥指定bit命名空间中的rand
	printf("%d\n", bit::rand); //10

	printf("%d\n", bit::Add(1, 1)); //2

	struct bit::Node p1;
	return 0;
}

(2)命名空间嵌套定义

namespace bit
{
	namespace add
	{
		int rand = 1;
		int Add(int left, int right)
		{
		return left + right;
		}
	}

	namespace Sub
	{
		int rand = 2;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

int main()
{
	printf("%d\n", bit::add::rand);  //1
	printf("%d\n", bit::add::Add(30, 10));  //40

	printf("%d\n", bit::Sub::rand);  //2
	printf("%d\n", bit::Sub::Sub(30, 10));  //20

	return 0;
}

(3)多文件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样

// Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
namespace bit
{
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;
	void STInit(ST* ps, int n);
	void STPush(ST* ps, STDataType x);
}


// Stack.cpp
namespace bit
{
	void STInit(ST* ps, int n)
	{
		assert(ps);
		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	} // 栈顶
	void STPush(ST* ps, STDataType x)
	{
		assert(ps);
		// 满了， 扩容
		if (ps->top == ps->capacity)
		{
			printf("扩容\n");
			int newcapacity = ps->capacity == 0 ? 4 : ps->capacity* 2;
			STDataType* tmp = (STDataType*)realloc(ps->a,newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
		ps->a[ps->top] = x;
		ps->top++;
	}
}


typedef struct Stack
{
	int a[10];
	int top;
}ST;
void STInit(ST* ps) {}
void STPush(ST* ps, int x){}

int main()
{
	// 调⽤全局的
	ST st1;
	//STInit(&st1);
	printf("%d\n", sizeof(st1));  //44

    // 合并头文件和源文件的bit域
	// 调⽤bit namespace的
	bit::ST st2;
	printf("%d\n", sizeof(st2));  //16
	return 0;
}

3.命名空间使用

• 指定命名空间访问，项目中推荐这种方式。
• using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
• 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

namespace bit
{
	int a = 0;
	int b = 1;
}

using bit::a;  //某个成员展开
using namespace bit;  //展开命名空间中全部成员

int main()
{
	printf("%d\n", a);
	printf("%d\n", a);
	printf("%d\n", a);
	printf("%d\n", a);
	printf("%d\n", a);
	printf("%d\n", a); 
	printf("%d\n", bit::b);  //指定命名空间访问

	return 0;
}

 三.C++ 输入（cin）& 输出（cout）

• <iostream> 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
• <<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
• 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入，输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
• cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们

#include <iostream>
using namespace std;
int main()
{
	int a = 0;
	double b = 0.1;
	char c = 'x';

	cout << a << " " << b << " " << c << endl;
	std::cout << a << " " << b << " " << c << std::endl;

	cin >> b >> c;
	cout << b << " " << c << endl;

	return 0;
}

补充：

#include<iostream>
using namespace std;
int main()
{
    // 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
    // 可以提⾼C++IO效率
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    return 0;
}

四.缺省参数

• 缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）。
• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值

  // 全缺省
  void Func1(int a = 10, int b = 20, int c = 30)
  {
  	cout << "a = " << a << endl;
  	cout << "b = " << b << endl;
  	cout << "c = " << c << endl << endl;
  }
  
  // 半缺省
  void Func2(int a, int b = 10, int c = 20)
  {
  	cout << "a = " << a << endl;
  	cout << "b = " << b << endl;
  	cout << "c = " << c << endl << endl;
  }
  
  int main()
  {
  	Func1();  // 没有传参时，使⽤参数的默认值  
  	Func1(1, 2, 3);  // 传参时，使⽤指定的实参
  
  	Func2();  //报错，不接受0个参数
  	Func2(100);
  	Func2(100, 200, 300);
  
  	return 0;
  }

  

// Stack.h
void STInit(ST* ps, int n = 4);

// Stack.cpp
// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
    assert(ps && n > 0);
    ps->a = (STDataType*)malloc(n * sizeof(STDataType));
    ps->top = 0;
    ps->capacity = n;
}

五.函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调⽤就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。

// 1、参数类型不同
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 Swap(int* px, int* py)
{}

void Swap(double* px, double* py)
{}

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

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


// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分
void fxx()
{}

int fxx()
{
     return 0;
}

namespace bit1
{
	void f1()
	{
		cout << "f(1)" << endl;
	}
}
void f1()
{
	cout << "f()" << endl;
}


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

int main()
{
	bit1::f1();  //f1()不构成重载，不在同一作用域中
	f1();

    //f2()  //f2()构成重载
            //f2()调⽤时，会报错，存在歧义，编译器不知道调⽤谁
	f2(1);  //正常
	return 0;
}

六.引用（&）

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

1.引用的特性

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

int main()
{
//	// 编译报错：“ra”: 必须初始化引用
//	//int& ra;

	// 引用：b和c是a的别名
    int a = 10;
	int& b = a;
	int& c = a;

	// 也可以给别名b取别名，d相当于还是a的别名
	int& d = b;
	++d;

	// 这里取地址我们看到是一样的
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
	return 0;
}

2.引用的使用

• 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。
• 引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。​​​​​​

//int& func()  //传引用返回不能这么使用，a出了作用域被销毁
//{
//	int a = 0; 
//	return a; 
//}

void Swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
} 

int main()
{
	int x = 0, y = 1;
	cout << x << " " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

 

（一）const 引用

• 可以引用⼀个常量对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
• 类型转换和表达式计算中会产生临时对象存储中间值，C++规定临时对象具有常性。
• 所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象

int main()
{
	const int a = 10;
	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”
	//int& ra = a;  // 这⾥的引⽤是对a访问权限的放⼤

    // 这样才可以
    const int& ra = a;

    // 这⾥的引⽤是对b访问权限的缩⼩
    int b = 20;
    const int& rb = b;  //权限的缩⼩

}

 

引用的时候权限可以缩小，但是不能放大

int main()
{
	int a = 10, b = 20;

    //下面三个都要加上const，不然都会造成权限放大    

	const int& rc = 30;  //常量具有常性
	const int& rd = (a + b);  //表达式计算产生临时对象，临时对象具有常性

	double d = 12.34;
	const int& ra = d;  // 类型转换，double转换成int 产生临时对象
}


//使用场景
void func(int& val) //通过引用传参，减少拷贝。但是局限性很大，具有常性的都无法传参
{

}

void func(const int& val)  //加上const就可以解决，但是要注意具体情况，是否要加const
{
        //比如swap函数,交换两个变量的值，我们要通过形参改变实参，就不要加const
}

（二）指针和引用的关系

• 语法概念上引用是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象
• 引用可以直接访问指向对象，指针需要解引用才能访问指向对象
• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些

七.inline （内联）

• 用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就需要建立栈帧了，就可以提高效率。
• C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂试，C++设计了inline目的就是替代C的宏函数。

// 实现一个ADD宏函数的常见问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)

// 正确的宏实现
//#define ADD(a, b) ((a) + (b))
 为什么不能加分号?  cout << 1 + 2; << endl; 报错
 为什么要加外面的括号?  ADD(1, 2) * 5 -> 1+2*5
 为什么要加里面的括号?  ADD(x & y, x | y) -> (x&y+x|y) &|优先级低于+-
//
//int main()
//{
//	int ret = ADD(1, 2); // int ret = ((1)+(2));
//	cout << ADD(1, 2) << endl;
//
//	cout << ADD(1, 2) * 5 << endl;
//
//	int x = 1, y = 2;
//	ADD(x & y, x | y); // -> (x&y+x|y)
//
//	return 0;
//}


inline int Add(int x, int y)
{
	int ret = x + y;
	return ret;
} 
int main()
{
	int ret = Add(1, 2);
	cout << Add(1, 2) * 5 << endl;
	return 0;
}

频繁调用的短小函数建议使用内联 

 八.nullptr

• nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换成任意其他类型的指针类型
• nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型 

建议在C++中使用nullptr就可以了，不使用NULL 

 今日节气大雪，注意保暖。