#include<iostream>
using namespace std;
void test01()//换行
{
	cout << "Hello World" << endl;
	//等价于cout << "Hello World\n" << endl;
}
void test02()//反斜杠
{
	cout<<"\\"<<endl;
	//打入两个反斜杠才输出一个反斜杠
}
void test03()//水平制表符\t
{
	//cout << "1111aaa\tHelloWorld" << endl;
	//\t占8个空格 主要是为了整齐的输出其后面的内容
	cout << "111aaa\thelloworld" << endl;
	cout << "111a\thelloworld" << endl;
	cout << "111aa\thelloworld" << endl;
	//
	cout << "111aaa helloworld" << endl;
	cout << "111a helloworld" << endl;
	cout << "111aa helloworld" << endl;
	//没有\t并不会自动对齐
}
int main()
{
	test03();
	system("pause");
	return 0;
}

//字符串型
//C语言的形式：char 变量名字[] = "字符串值";
//C++的形式：string 变量名字 = "字符串值";

#include<iostream>
using namespace std;
//#include<string>
int main()
{
	char str[] = "Hello World";
	cout << str << endl;
	string arr = "Hello World";
	//包含头文件
	cout << arr << endl;
	return 0;
}

<details>
<summary>点击查看代码</summary>

include

using namespace std;

int main()
{
bool flag = true;
cout << flag << endl;
//结果为1
flag = false;
cout << flag << endl;
//结果为0
cout << sizeof(bool) << endl;
//bool所占内存空间：1个字节大小
return 0;
}

</details>

#include<iostream>
using namespace std;

int main()
{
	 //取模
	cout << 10 % 20 << endl;//10
	cout << 10 % 3 << endl;//1
	cout << 10 % 0 << endl;//10不可以除以0
	//cout << 1.1 % 2.1 << endl;//两个小数是不可以进行取模运算的

	return 0;
}

#include<iostream>
using namespace std;
//#include<ctime>
int main()
{
	//添加随机数种子
	//利用当前系统的时间去生成随机数 防止每一次随机数都一样
	srand((unsigned int)time(NULL));
	int num1 = rand() % 100;//产生0到99
	int num2 = rand() % 100 + 1;//产生1到100
	int num3 = 0;
	for (int i = 1;1; i++)
	{
		cin >> num3;
		if (num3 > num1)
		{
			cout << "猜大了" << endl;
		}
		else if (num3 < num1)
		{
			cout << "猜小了" << endl;
		}
		else
		{
			cout << "猜对了" << endl;
			break;
		}
	}
	return 0;
}

#include<iostream>
using namespace std;
//成员变量 和 成员函数 是分开存储的
class Person
{
	int m_A;//非静态的成员变量 - 属于类的对象上
	static int m_B;//静态成员变量 - 不属于类的对象上
	void func(){}//非静态的成员函数 - 不属于类的对象上 
	static void funcc(){} //静态成员函数 - 不属于类的对象上
};
int Person::m_B = 190;
void test01()
{
	Person p1;
	//空对象 占用的内存空间为：1
	cout << sizeof(p1) << endl;//1
	//每个空对象也应该有一个独一无二的内存空间地址
}
void test02()
{
	Person p1;
	cout << sizeof(p1) << endl;//4
}
int main() 
{
	//只有非静态的成员变量才属于类的对象上
	test02();
	return 0;
}

#include<iostream>
using namespace std;
class Person
{
public:
	Person(int age)
	{
		//this指针
		//this指针指向 被调用的成员函数 所属的对象
 
		this->age = age;
	}
	//Person PersonAddAge(Person& p) 以值的方式去返回
	Person& PersonAddAge(Person& p)
	{
		this->age += p.age;
		//this指向的就是p2的指针 那么*this就是指向的p2这个对象本体
		return *this;
		//返回本体需要使用引用的方式
	}
	int age;
};
//解决名称冲突
void test01()
{
	Person p1(190);
	cout << p1.age << endl;
}
//返回对象本身使用*this

void test02()
{
	Person p1(190);
	Person p2(191);
	//p2.PersonAddAge(p1);
	Person p3(1);
	p2.PersonAddAge(p1).PersonAddAge(p3).PersonAddAge(p3);
	//链式编程思想
	cout << p2.age << endl;
}
int main()
{
	test02();
	//190+191=381
	return 0;
}

#include<iostream>
using namespace std;
//空指针访问成员函数
class Person
{
public:
	void ShowAge()
	{
		cout << "Age" << endl;
	}
	void Showage()
	{
		if (this == NULL)
		{
			return;
		}
		//cout << m_Age << endl;
		//传入的指针是为空的(NULL)
		cout << this->m_Age << endl;

	}
	int m_Age;
};
void test01()
{
	Person* p = NULL;
	//p->ShowAge();
	p->Showage();
}
int main()
{
	test01();
	return 0;
}

#include<iostream>
using namespace std;
class Person
{
public:
	//this指针的本质就是：指针常量 
	//指针常量 是常量 不是指针 指针的指向是不可以修改的
	void showPerson() const//常函数
	{
		m_B = 191;
		this->m_B = 190;//未报错
//因为 this指针的本质可以表示为：Person* const this;是一个指针常量 在Person*前面在加一个const
//const Person* const this; 就是对应得值也不可以修改了 等价于我们在成员函数后面加const 
	//所以说在成员函数后面加const 修饰的就是this指针 让指针指向的值也不可以修改
//m_A = 100;
		// 等价于this->m_A = 100; 
		//this = NULL;//this指针是不可以修改指针的指向的

		//不想被修改值 需要在函数名字后面加const
	}
	int m_A;
	mutable int m_B;//可以在常函数当中修改成员变量的值
};
//在成员函数后面加上const 该函数称为常函数
//常函数内部是不可以修改成员属性的
//成员属性声明的时候加关键字mutable之后 可以在常函数当中修改
void test01()
{
	Person p;
	p.showPerson();
}
//在声明对象的前面加上const 这个对象叫做常对象
//常对象只可以调用常函数

int main()
{
	test01();
	return 0;
}

#include<iostream>
using namespace std;
class Person
{
public:
	void func()
	{
		m_A = 1;
	}
	//this指针的本质就是：指针常量 
	//指针常量 是常量 不是指针 指针的指向是不可以修改的
	void showPerson() const//常函数
	{
		m_B = 191;
		this->m_B = 190;//未报错
//因为 this指针的本质可以表示为：Person* const this;是一个指针常量 在Person*前面在加一个const
//const Person* const this; 就是对应得值也不可以修改了 等价于我们在成员函数后面加const 
	//所以说在成员函数后面加const 修饰的就是this指针 让指针指向的值也不可以修改
//m_A = 100;
		// 等价于this->m_A = 100; 
		//this = NULL;//this指针是不可以修改指针的指向的

		//不想被修改值 需要在函数名字后面加const
	}
	int m_A;
	mutable int m_B;//可以在常函数当中修改成员变量的值
};
//在成员函数后面加上const 该函数称为常函数
//常函数内部是不可以修改成员属性的
//成员属性声明的时候加关键字mutable之后 可以在常函数当中修改
void test01()
{
	Person p;
	p.showPerson();
}
//在声明对象的前面加上const 这个对象叫做常对象
//常对象只可以调用常函数

void test02()
{
	const Person p; //在对象的前面 加上 const 变为常对象
	//依然不允许修改指针指向的值
	//p.m_A = 100;//no
	p.m_B = 190;//yes
	//m_B 是特殊值 在常对象下面也可以修改
//常对象只可以调用常函数
	p.showPerson();
	//p.func();
	//常对象 不可以调用普通的成员函数 因为普通的成员函数是可以修改属性的
}
int main()
{
	test01();
	return 0;
}