#include <iostream>
using namespace std;

bool isLeapYear(unsigned int year)
{
	// 双分支if
	//if ( (year % 400 == 0) ||  (year%4==0 && year%100 != 0) )
	//这里有个if的优化，因为||操作符，第一个条件满足不看后面的，&&操作符第一个条件不满足不看后面的
	//所以按下面的方式效率更高，因为涉及命中率问题，被4整除的概率更高
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main()
{
    // 是否是闰年
	cout << isLeapYear(2000) << endl;
	cout << isLeapYear(2020) << endl;
	cout << isLeapYear(2021) << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
	// b是否是a的倍数
	int a = 0;
	int b = 4;
	//短路运算，除数不能为0。千万别写反了
	if ((a != 0) && b % a == 0)
	{
		cout << "b是a的倍数" << endl;
	}
	else
	{
		cout << "b不是a的倍数" << endl;
	}

	return 0;
}

switch(表达式)
{
	case 常数1：语句1; break;
	case 常数2：语句2; break;
	case 常数3：语句3; break;
	default : 语句;
}

#include <iostream>
using namespace std;

typedef enum __COLOR
{
	RED,
	GREEN,
	BLUE,
	UNKOWN
}COLOR;

int main()
{
	// 多分支条件的if
	// if, else if, else
	COLOR color0;
	color0 = BLUE;
	int c0 = 0;
	if (color0 == RED) {
		//cout << "red" << endl; 
		c0 += 1;
	}
	else if (color0 == GREEN) {
		//cout << "green" << endl; 
		c0 += 2;
	}
	else if (color0 == BLUE) {
		//cout << "blue" << endl;
		c0 += 3;
	}
	else {
		//cout << "unknown color" << endl; 
		c0 += 0;
	}

	// 多分支条件的switch
	// switch,case,default
	COLOR color1;
	color1 = GREEN;
	int c1 = 0;
	switch (color1)
	{
	case RED:
	{
		//cout << "red" << endl;
		c1 += 1;
		break;
	}
	case GREEN:
	{
		//cout << "green" << endl; 
		c1 += 2;
		break;
	}
	case BLUE:
	{
		//cout << "blue" << endl;
		c1 += 3;
		break;
	}
	default:
	{
		//cout << "unknown color" << endl;
		c1 += 0;
		break;
	}
	}


	return 0;
}

//计算1 + 2 + …… + 99 + 100的和

#include <iostream>
using namespace std;
int main()
{   // TODO: 1+2+3+4...+100
	// while语句
	int sum = 0;
	int index = 1;
	while (index <= 100)
	{
		sum += index;
		index += 1;
	}
	cout << sum << endl;

	// for语句
	index = 1;
	sum = 0;
	for (index = 1; index <= 100; ++index)
	{
		sum += index;
	}
	cout << sum << endl;

	// do-while语句
	sum = 0;
	index = 1;
	do
	{
		sum += index;
		index += 1;
	} while (index <= 100);
	cout << sum << endl;

	return 0;
}

#include <iostream>
using namespace std;
#include <math.h>

int main()
{
	// aabb的完全平方数

	//方法一：一个显而易见的方法
	int n = 0;
	double m = 0;
	for (size_t a = 1; a < 10; a++)
	{// for1
		for (size_t b = 0; b < 10; b++)
		{// for 2
			n = a * 1100 + b * 11; //aabb
			//求平方根，看是否是整数
			m = sqrt(n);          
			if (m - int(m) < 0.00000001)  //当差值小于一个极小值即可，这个值和浮点数的精度有关
			{
				cout << n << endl;
			}
		}// for 2
	}// for1


	//方法二：逆向思维
	//先保证是平方根，再看是否是aabb类型
	//这样做第一不需要双层循环，第二避免了开平方根造成的精度丢失和低速运算
	int high, low;

	//不需要从1开始，31*31=961，32*32=1024
	for (size_t index = 31; ; index++)
	{
		n = index * index; //n就是我们要构造的完全平方数
		if (n < 1000)
			continue;   // 继续下一次循环
		if (n > 9999)
			break;        // 退出循环
		high = n / 100;   // 4567/100 = 45
		low = n % 100;   // 4567%100 = 67
		if ((high / 10 == high % 10) && (low / 10 == low % 10))   // 判断aa， bb
		{
			cout << n << endl;
		}
	}

	return 0;
}

//两个数交换：
int swap(int& p, int& q)
{
	int temp = p;
	p = q;
	q = temp;
}


//两个指针交换：
int ptrswap(int* &v1. int* &v2) //v1是个引用，于指向int型对象的指针关联
{
	int* tmp = v2;
	v2 = v1;
	v1 = tmp;
}

int mal(int a, int b = 3, int c = 6, int d = 8)；

int mal(1); //b、c、d使用默认参数

int printf(const char* format, ...);

//接受可变参数的函数实现多个数相加
int add(int num, ...)
{
	int sum = 0;
	int index = 0;
	int* p = (int*)&num + 1;
	for(; index < num; ++index){
		sum += *p++;
	}
}

int main()
{
	int i = 1, j = 2, k = 3;
	cout << add(3, i, j, k);
	return 0;
}

#include <iostream>
using namespace std;
#include <math.h>

int test(int a)
{
	return a;
}

int test(double a)
{
	return int(a);
}

int test(int a, double b)
{
	return a + b;
}

int main()
{
	int result = test(1);
	result = test(2.0);
	result = test(1, 2.0);

	return 0;
}

#include <iostream>

int test(int a)
{
	return a;
}

int test(double a)
{
	return int(a);
}

int test(int a, double b = 2.0)
{
	return a + b;
}

int main()
{
	//int test(int a)和int test(int a, double b = 2.0)都满足下面这个调用方法
	int result = test(1);

	//为了解决重载问题，可以使用函数指针调用
	int(*p)(int);  //定义一个指针p，表示参数是int，返回值是int的一个函数
	p = test;   //指针变量赋值，此时虽然有三个同名函数，但明确指向的是参数为int的函数
	int result = (*p)(1); //函数指针的使用，此时*p是间接引用


	return 0;
}

#include <iostream>
using namespace std;

int MaxValue(int x, int y)
{
	return (x > y) ? x : y;
}

int MinValue(int x, int y)
{
	return (x < y) ? x : y;
}

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

bool ProcessNum(int x, int y, int(*p)(int a, int b)) //参数中有函数指针
{
	cout << p(x, y) << endl;
	return true;
}

int main()
{
	int x = 10, y = 20;

	//直接用函数名做参数，只要保证函数的参数列表是两个int，返回值是int就可以
	ProcessNum(x, y, MaxValue);
	ProcessNum(x, y, MinValue);
	ProcessNum(x, y, Add);

	return 0;
}

#include <iostream>
using namespace std;

int test(int a)
{
	return a;
}

namespace AA
{
	int test(int a)
	{
		return a + 1;
	}
}

int main()
{
	cout << test(1) << endl; //全局的

	cout << AA::test(1) << endl; //AA中的

	return 0;
}

inline int MaxValue(int x,int y)
{
	return (x > y) ? x : y;
}

// 使用循环来代替递归调用
int Fib3(int n)
{
	if (n < 2)
	{
		return n;
	}
	int n0 = 0, n1 = 1;
	int temp;
	for (int i = 2; i <= n; i++)
	{
		temp = n0;
		n0 = n1;
		n1 = temp + n1;
	}
	return n1;
}

//循环调用避免了每次递归创建的函数入栈操作，减小空间使用
//也减少了重复运算

//尾递归
int Fib2(int n, int ret0,  int ret1) //ret0和ret1入参是斐波那契的第一个值和第二个值
{
	if (n == 0)
	{
		return ret0;
	}
	else if (n == 1)
	{
		return ret1;
	}
	return Fib2(n - 1, ret1, ret0 + ret1);
}

//使用普通递归，return Fib(n-1) + Fib(n-2)是一个表达式，函数堆栈很复杂
// 每次递归调用都需要保存多个函数调用堆栈


//尾递归直接Fib2(n - 1, ret1, ret0 + ret1)，只是简单的函数调用，编译器会帮我们做优化

//动态规划
int g_a[1000]; // 全局的数组，记录斐波那契数列的前1000个值

int Fib4(int n)
{
	//assert(n >= 0);
	g_a[0] = 0;
	g_a[1] = 1;
	for (int i = 2; i <= n; i++)
	{
		if (g_a[i] == 0) //全局变量初始化值为0，g_a[i]==0代表没计算过
		{
			g_a[i] = g_a[i - 1] + g_a[i - 2];
		}
	}
	return g_a[n];
}


//动态规划的思想就是空间换时间
//把曾经计算过的信息保存下来，不需要重复计算

int main()
{
	int a = 1;
	float b = 3.14f;

	//指针变量定义
	int* c = &a;  //c存储a的内存地址
	float* d = &b; //d存储b的地址

	cout << c << endl;   //输出a变量的地址

	//间接访问
	cout << (*c) << endl; //等同于cout<<a<<endl;
	cout << (*d) << endl;//等同于cout<<b<<endl;

	return 0;
}

int main()
{
	//两种字符串表示
	char strHello[] = { "hello" };
	const char* pStrHello = "hello";

	pStrHello = strHello;   //正确，指针变量的值可以改变
	strHello = pStrHello;   //编译器报错，数组变量的值不允许改变
	return 0;
}

int i = 4;
int* iP = &i;
cout<<(*iP)<<endl; //这俩的*含义不一样，一个是指针，一个是间接引用

double d = 3.14;
double* dP =&d;
cout << (*dP) << endl;

int* a[4];  //一个数组，每个元素都是int指针

int c[4] = {1,2,3,4};
int(*b)[4];  //声明一个数组指针，可以指向包含4个int元素的数组
b = &c;  //数组的个数一定要匹配！这里是&c,c的类型是int*,&c的类型是int(*)[4]

//将数组c中的元素赋值给数组a：
for(unsigned int i = 0; i < 4; i++)
{
	a[i] = &(c[i]);
}


int *p = a;  //p是指向a数组首元素的指针

//输出数组内容：
cout<<*(a[0])<<endl;  //先取数组下标得到地址，然后做间接访问
cout<<(*b)[3]<<endl;  //b是指针，先间接访问取值得到数组，然后取数组下标

int main()
{
	char strHello[] = { "helloworld" };

	char const* pStr1 = "helloworld";  //修饰char，指针指向的地址可变，但是存储的区域中的内容不可变
	char* const pStr2 = "helloworld"; //修饰char*，指针指向的地址不可变。在最新的VS中编译不过，因为"helloworld"是常量，必须要用const指针
	const char* const pStr3 = "helloworld"; //地址和空间中的内容都不允许改变

	pStr1 = strHello;
	//pStr2 = strHello;   //错误，pStr2地址不可改
	//pStr3 = strHello;   //错误，pStr3地址不可改 

	//pStr1[1] = 'a';   //错误，存储区内的char不可改变
	pStr2[1] = 'a';
	//pStr3[1] = 'a';   //错误，存储区内的char不可变

	return 0;
}

int a = 123;
int* b = &a;
int** c = &b; //二级指针

int* a;  //只声明不赋值,a指向哪里完全不知道
*a = 12;//错误！！

int* a = NULL;

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

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

int main()
{
	int* pi = NULL;
	int* pi2 = nullptr;
	char* pc = NULL;
	char* pc2 = nullptr;
	func(NULL);                   // func(int i)
	func(nullptr);                 // func(void* i)
	func(pi);                         // func(void* i)
	func(pi2);                       // func(void* i)
	func(pc);                        // func(void* i)
	func(pc2);                      // func(void* i)



    return 0;
}

bool (*pf)(const string&, const string&)

//pf声明为指向函数的指针
//它所指向的函数带有两个const string&类型形参和bool类型的返回值
//*pf两侧的圆括号是必须的

typedef bool (*cmpFcn)(const string&, const string&);

//cmpFun是一种指向函数的指针类型的名字。
//该指针类型为“指向返回bool类型并且带有两个const string&引用形参的函数的指针”
//在使用这种函数指针类型时，只需直接使用cmpFcn即可，不必每次都把整个类型声明全部写出来

bool lengthCompare(const string&, const string&);
cmpFun pf = lengthCompare;
lengthCompare("h1", "bye");	//直接调用
pf("h1", "bye");	//利用函数指针调用，未使用*
(*pf)("h1", "bye");	//利用函数指针调用，使用*

void useBigger(const string&, const string&, bool(const string&,const string&));
void useBigger(const string&, const string&, bool(*)(const string&,const string&));

int (*ff(int))(int*, int);

//由里向外理解
//先看ff(int)，ff声明为一个函数，带有一个int形参
//ff数返回int(*)(int*, int)

//为了方便理解，可以这么写：
typedef int (*PF)(int*, int);
PF ff(int);

char ch = 'a';
char* cP = &ch;

*cp = 'b';  //左值，取的是空间

char tmp = *cp; //右值，取的是内容

int main()
{
	char ch = 'a';
	
	//&操作符
	//&ch = 97;      //错误，&ch左值不合法
	char* cp = &ch; //&ch做右值
	//&cp = 97;		//错误，&左值不合法
	char** cpp = &cp;		//&cp右值


	//*操作符
	*cp = 'a';				//*cp左值取变量ch的位置
	char ch2 = *cp;			//*cp右值取变量ch存储的值
	//*cp + 1 = 'a';			//错误，*cp+1左值不合法的位置
	ch2 = *cp + 1;			//*cp+1右值取到的字符做ASCII码+1操作
	*(cp + 1) = 'a';			//左值，语法上合法，访问到cp后面的位置，赋值为a.一定要保证这个位置是可以访问的，这种操作有风险
	ch2 = *(cp + 1);			//右值操作，取ch后面的位置的值
}

char* cp2 = ++cp;
//汇编代码：
mov		eax,dword ptr [cp]		//eax是寄存器，dwptr存储cp指针。把指针内容放置寄存器内
add		eax,1					//寄存器数据+1
mov		dword ptr [cp],eax		//把寄存器内容存回cp中
mov 	ecx,dword ptr [cp]		//把cp的内容放置在ecx寄存器
mov		dword ptr [cp2],ecx		//把寄存器ecx内容放置在cp2中

char* cp3 = cp++;
//汇编代码：
mov		eax,dword ptr[cp]		//把cp指针内容放置在eax寄存器中
mov		dword ptr[cp3],eax		//把eax内容直接放在cp3指针
mov		ecx,dword ptr[cp]		//把cp信息放置在exc寄存器中
add		ecx,1					//ecx+1操作
mov		dword ptr[cp],ecx		//ecx内容写入cp指针

int a = 1,b=2；
int c;
int d;
c = a+++b;   //相当于a++ +b。连续读取，当读取到两个+号时不能再组成新符号了
d = a++++b;	//相当于a++ ++b。这个是错误的 ，两个表达式之间不构成任何运算

#include <iostream>
using namespace std;

int  a = 0;                       //GVAR全局初始化区
int* p1;						  //BSS全局未初始化区

int main()						 //text 代码区
{
	int b = 1;					//stack栈区
	char s[] = "abc";			//stack栈区
	int* p2 = NULL;				//stack栈区

	const char* p3 = "123456";	//"123456\0"在常量区，p3在stack栈区

/*
	char* p3 = "123456";这条语句“123456”在内存中只有一份拷贝，p3只是个指针变量
	char s[] = "abc";这条语句，“abc”在内存中有两份拷贝，一份在字符常量区，一份在s所在的栈区
*/

	static int c = 0;			//GVAR全局(静态)初始化区

	p1 = new int(10);			//heap堆区变量
	p2 = new int(20);			//heap堆区变量

	char* p4 = new char[7];		//heap堆区变量
	strcpy_s(p4, 7, "123456");	//text代码区

	if (p1 != NULL)
	{
		delete p1;
		p1 = NULL;
	}

	if (p2 != NULL)
	{
		delete p2;
		p2 = NULL;
	}

	//p3指向常量区，由内存接管

	if (p4 != NULL)
	{
		delete[] p4;
		p4 = NULL;
	}

	return 0;
}

#include <string>
#include <iostream>
#include <memory> //智能指针头文件
using namespace std;
int main()
{
	{// 确定auto_ptr失效的范围
		// 对int使用
		auto_ptr<int> pI(new int(10));      //关注pI的生命周期范围和指向的堆区空间的声明周期范围
		cout << *pI << endl;                // 10 

		// auto_ptr	C++ 17中移除	拥有严格对象所有权语义的智能指针
		// auto_ptr原理：在拷贝 / 赋值过程中，直接剥夺原对象对内存的控制权，转交给新对象，
		// 然后再将原对象指针置为nullptr（早期：NULL）。这种做法也叫管理权转移。
		// 他的缺点不言而喻，当我们再次去访问原对象时，程序就会报错，所以auto_ptr可以说实现的不好，
		// 很多企业在其库内也是要求不准使用auto_ptr。

		//对字符串数组使用
		auto_ptr<string> languages[5] = {
			auto_ptr<string>(new string("C")),
			auto_ptr<string>(new string("Java")),
			auto_ptr<string>(new string("C++")),
			auto_ptr<string>(new string("Python")),
			auto_ptr<string>(new string("Rust"))
		};
		cout << "There are some computer languages here first time: \n";
		for (int i = 0; i < 5; ++i)
		{
			cout << *languages[i] << endl;
		}
		auto_ptr<string> pC;
		pC = languages[2]; // languges[2] loses ownership. 将所有权从languges[2]转让给pC!!!
		//此时languges[2]不再引用该字符串从而变成空指针
		cout << "There are some computer languages here second time: \n";
		for (int i = 0; i < 2; ++i)
		{
			cout << *languages[i] << endl;
		}
		cout << "The winner is " << *pC << endl;
		//下面会报错
		//cout << "There are some computer languages here third time: \n";
		//for (int i = 0; i < 5; ++i)
		//{
		//	cout << *languages[i] << endl;
		//}
	}

	//出了大括号，auto_ptr的内存被回收
	return 0;
}

//xmemory文件

//观察auto_ptr的模板可以看到它是怎么实现资源释放和所有权转移的

//资源释放：是通过析构来完成的
~auto_ptr() noexcept {
        delete _Myptr;
    }


//所有权转移，观察赋值的重载：
auto_ptr& operator=(auto_ptr& _Right) noexcept {
        reset(_Right.release());   //保存原有的地址，把原有保存这个地址的指针置成nullptr
        return *this;
    }

#include <memory>
#include <iostream>
using namespace std;
int main()
{
	// 在这个范围之外，unique_ptr被释放
	{
		auto i = unique_ptr<int>(new int(10));
		//i在栈区，指向一个堆区分配的区域
		cout << *i << endl;
	}//大括号结束后，i自动释放，指向的堆区内部也自动delete

	// unique_ptr
	auto w = std::make_unique<int>(10);
	cout << *(w.get()) << endl;                          // 10。get()方法返回的就是指针

	//auto w2 = w;  // 编译错误！！如果想要把 w 复制给 w2, 是不可以的。
	//  因为复制从语义上来说，两个对象将共享同一块内存。

	// unique_ptr 只支持移动语义, 即如下
	auto w2 = std::move(w); // w2 获得内存所有权，w 此时等于 nullptr
	cout << ((w.get() != nullptr) ? (*w.get()) : -1) << endl;       // -1
	cout << ((w2.get() != nullptr) ? (*w2.get()) : -1) << endl;   // 10
	return 0;
}

#include <iostream>
#include <memory>
using namespace std;
int main()
{
	// shared_ptr 
	{
		//shared_ptr 代表的是共享所有权，即多个 shared_ptr 可以共享同一块内存。
		auto wA = shared_ptr<int>(new int(20));
		{
			auto wA2 = wA;          //shared_ptr可以赋值，同时指向对象
			cout << ((wA2.get() != nullptr) ? (*wA2.get()) : -1) << endl;       // 20
			cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;         // 20
			cout << wA2.use_count() << endl;              // 打印引用计数 2
			cout << wA.use_count() << endl;               // 打印引用计数 2
		}
		//cout << wA2.use_count() << endl;                                               
		cout << wA.use_count() << endl;                  // wA2消亡，引用计数为1
		cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;        // 20
		//shared_ptr 内部是利用引用计数来实现内存的自动管理，每当复制一个 shared_ptr，
		//	引用计数会 + 1。当一个 shared_ptr 离开作用域时，引用计数会 - 1。
		//	当引用计数为 0 的时候，则 delete 内存。
	}
	//跳出作用域，wA也消亡，同时内存会被释放

	// shared_ptr也支持move()语法
	auto wAA = std::make_shared<int>(30);
	auto wAA2 = std::move(wAA); // 此时 wAA 等于 nullptr，wAA2.use_count() 等于 1
	cout << ((wAA.get() != nullptr) ? (*wAA.get()) : -1) << endl;          // -1
	cout << ((wAA2.get() != nullptr) ? (*wAA2.get()) : -1) << endl;      // 30
	cout << wAA.use_count() << endl;              // 0
	cout << wAA2.use_count() << endl;             // 1
	//将 wAA 对象 move 给 wAA2，意味着 wAA 放弃了对内存的所有权和管理，此时 wAA对象等于 nullptr。
	//而 wAA2 获得了对象所有权，但因为此时 wAA 已不再持有对象，因此 wAA2 的引用计数为 1。

	return 0;
}

#include <string>
#include <iostream>
#include <memory>
using namespace std;

struct B;
struct A {
	shared_ptr<B> pb;
	~A()
	{
		cout << "~A()" << endl;
	}
};
struct B {
	shared_ptr<A> pa;
	~B()
	{
		cout << "~B()" << endl;
	}
};

// pa 和 pb 存在着循环引用，根据 shared_ptr 引用计数的原理，pa 和 pb 都无法被正常的释放。
// weak_ptr 是为了解决 shared_ptr 双向引用的问题。
struct BW;
struct AW
{
	shared_ptr<BW> pb;
	~AW()
	{
		cout << "~AW()" << endl;
	}
};
struct BW
{
	weak_ptr<AW> pa;
	~BW()
	{
		cout << "~BW()" << endl;
	}
};

void Test()
{
	cout << "Test shared_ptr and shared_ptr:  " << endl;
	shared_ptr<A> tA(new A());                                               
	shared_ptr<B> tB(new B());                                                
	cout << tA.use_count() << endl;  //1
	cout << tB.use_count() << endl;  //1
	tA->pb = tB;
	tB->pa = tA;
	cout << tA.use_count() << endl;     // 2
	cout << tB.use_count() << endl;     // 2
}
void Test2()
{
	cout << "Test weak_ptr and shared_ptr:  " << endl;
	shared_ptr<AW> tA(new AW());
	shared_ptr<BW> tB(new BW());
	cout << tA.use_count() << endl;    // 1
	cout << tB.use_count() << endl;    // 1
	tA->pb = tB;
	tB->pa = tA;   //tB->pa是weak_ptr，指向tA但不会对tA的引用计数产生影响
	cout << tA.use_count() << endl;    // 1
	cout << tB.use_count() << endl;    // 2
}

int main()
{
	Test();
	Test2();


	return 0;
}

int x1 = 1,x2 = 3;
int& rx = x1;	//定义引用，可以认为rx是x1的别名
rx = 2;
cout << x1 << rx << endl;	//x1和rx都是2
rx = x2;		//引用一旦被初始化就不能更改，所以这里不是赋值rx为x2，而是x1=x2(别名直接替换)
cout << x1 << x2 << endl;		//都是3

#include <iostream>
#include <assert.h>
using namespace std;

// 编写一个函数，输入两个int型变量a,b
// 实现在函数内部将a,b的值进行交换。
void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
void swap2(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int main()
{
	// 交换变量的测试
	int a = 3, b = 4;
	swap(a, b);
	assert(a == 4 && b == 3);

	a = 3, b = 4;
	swap2(&a, &b);
	assert(a == 4 && b == 3);

    return 0;
}

class ConstRef
{
public:
	ConstRef(int ii) : i(ii), ci(i), ri(ii) { }
private:
	int i;
	const int ci;
	int& ri;
};

const char* pStrHelloWorld = "helloworld";

int main()
{
	//char strHello[10] = { "helloworld" };  //错误定义，没有给'\0'留空间

	char strHello[11] = { "helloworld" };
	char strHello[] = { "helloworld" };  //这样定义也可以
	//strHello是数组变量，它本身的值是不允许改变的，但是它指向的区域的值strHello[index]是可以改变的
	strHello[2] = '6';    //strHello = he6loworld
	//strHello = { "helloworld" };    //本身不允许改变，编译不通过


	//ptrHello是指针变量，它本身是可以改变的，但是ptrHello[index]指向的值可变与否要取绝与所指向的区间是否可以改变
	const char* ptrHello_1 = "helloworld";  //指针指向常量区(必须要加const)，ptrHello[index]不可改变，但本身指向的地址可以变。
	ptrHello_1 = "change";

	char tmp[7] = "change";
	char* ptrHello_2 = strHello;      //指针指向数组变量，ptrHello[index]可以改变,本身也可以变
	ptrHello_2[2] = 'l';
	ptrHello_2 = tmp;

	return 0;
}

const char *cp = "helloworld";
while(*cp)
{
	//do something
	++cp;
}

strlen(s);    //返回字符串s的长度，要注意字符串的长度不包含'\0'。

sizeof(s);   //返回字符串所占用的空间，包含'\0'


int main()
{
	char strA[11] = "helloworld";
	auto n1 = sizeof(strA);     //11
	auto n2 = strlen(strA);     //10


	wchar_t strB[11] = L"helloworld";
	auto n3 = sizeof(strB);        //22
	auto n4 = wcslen(strB);        //10

	return 0;
}

//自定义实现strlen
int strlen(const char* str)
{
	assert(str != NULL);
	int len = 0;
	while((*str++) != '\0'){
		len++;
	}
	return len;
}

//或者不使用临时变量,用递归：
int strlen(const char* str)
{
	assert(str != NULL);
	return *str == '\0' ? 0 : (1 + strlen(++str));
}

strcmp(s1,s2); 
wcscmp(s1,s2); 
//s1 == s2,返回0
//s1 < s2 ,返回值小于0
//s1 > s2 ，返回值大于0

//自定义实现strcmp：
int strcmp(const char* str1, const char* str2)
{
	assert(str1 != NULL && str2 != NULL);
	int ret = 0;
	while(!(ret = *(unsigned char*)str1 - *(unsigned char*)str2) && str1)
	{
		str1++;
		str2++;
	}
	if(ret < 0)  ret = -1;
	else if(ret > 0)  ret = 1;

	return ret;
}

strcpy(s1,s2);   //赋值字符串s2到字符串s1的地址空间

strncpy(s1,s2,n);   //将字符串s2中的前n个字符拷贝到s1的地址空间

//自定义实现strcpy
char* strcpy(char* strDestination, const char* strSource)
{
	assert(strDestination != NULL && strSource != NULL);
	char* strD = strDestination;
	while((*strDestination++ = *strSource++) != '\0');
	return strD;
}

//从src所指向的内存地址起始位置开始拷贝n个字节到dest所指的内存地址的起始位置中。返回指向dest的指针
void* memcpy(void* dest, const* src, size_t n); 

strcat(s1,s2);   //将字符串s2拼接到s1后面(覆盖s1的'\0'),返回s1

strncat(s1, s2, n); //将s2的前n个字符拼接到s1，并返回s1

//自定义实现strcat：
char *strcat(char* strDest, const char* strSrc)
{
	char* address = strDest;
	assert((strDest != NULL) && strSrc != NULL);
	while(*strDest)  //如果是strncat，这里用n作为结束标志
	{
		strDest++;
	}
	while(*strDest++ = *strSrc++);
	return address;
}