变量和基本类型
1 内存：最基本的东西，你必须了解这个概念，如果非要理解，就认为它是一个【盒子】。
2 变量：地盘。（）
理性理解：盒子有无数纸，其中一张框出的一个区域。
感性理解：黑帮老大在尖沙咀有片地，有一天，他忙不过来，叫手下帮忙管，于是叫手下a管东边，手下b管西边，手下c管…….而变量，就是手下管的地。
如下：
int a = 1;
表达什么？
通俗点：我叫一个叫a的家伙给我管地，让他开一个叫"1"的角斗场。
理性点：
我：电脑大人，给我一片内存区域，我要存点东西。
电脑：好，给你，但是你得告诉我，你要什么样的地，这块地你得给它起个名字，不然以后我怎么收回来。
我：我要【int】的地，它就叫a吧，简单好记。
3 变量的类型
bool：只能存放【true】或者【false】。（1以上他会直接算true，0位false）
char：表示字符，如"T"。
short：短整型，范围-32768~32767。
int：整型，范围-2147483648~2147483647。
long：长整型，范围-2147483648~2147483647
float：单浮点，范围-3.4*10的38次方~3.4*10的38次方。
double：双浮点，范围-1.7*10的308次方~1.7*10的308次方。
string：字符串，如“string不是最基本的数据类型，它在C++里是标准库，比较常用。”
上面这些都是比较常用的long long,wchar_t,char16_t,char32_t,long double请查阅资料。
如果规定必须使用0包含0以上的，则在前面增加unsigned。
具体使用：
bool flag = true;
char c = '\n';
short = -123;
unsigend short = 123; //不能使用负数，因为规定unsigned
int a=1, b=2, c=3, d = 4;//声明并定义a,b,c,d分别赋值1,2,3,4
long q,w,e,r;
float f = 1.3;//注意不是floa和double如果非要赋值非整数，那会取整，一般截断处理。如int a = 1.6，则在计算是a = 1。而不是1.6
double f = 21321314.213123123124;//和float的区别在于，它能存更大或更小更长的数，你说气不气。
以前的程序员大哥，那用盒子的区域是相当小，得省吃捡用，所以能用float绝对不用double，能用short绝不用int，因为地就那么大。

控制台程序运行
1 重点：学程序最重要的是什么？【实践】！【实践】！【实践】！还是TM的【实践】！
！！！！！！！！！没有之一！！！！！！！！！
我学过程序，学过画画，虽然给我的感觉是，画画--地狱难度，程序--简单难度。但是没有【实践】作为大前提，简单难度打个问号。
2 这里我们以C++为主要语言。
1、首先，你需要编译器，请百度VS2019、VS2017、都可以，社区版免费。
2、下载完成后，新建，语言为C++，然后控制台程序。
3、按F5运行，你就可以见到，程序教科书上，最经典的一句话，“Hello World！”
4、很好，在里面随便敲点什么，别管3721，写上中文都可以。
5、接着F5运行。
6、然后，你会发现，不能运行，或者报错，恭喜你，找到了成功的妈妈，现在，请热情问候她。因为，她是世界上对你最好的人。
7、为什么，因为我们得按照规矩敲代码。为什么，因为“规矩”不讲道理。
总结一下：你需要实践，成功是垃圾，失败才是宝藏，写代码有规矩。
3 正题：打开程序后，你会看到这些，什么意思呢，解释给你听。


下来，尝试用我们学过变量知识写出代码。
# include<iostream>
int main()
{
int a = 1, b = 2, c;
c = a + b;
std::cout << "c = " << c;
}
F5运行

方式
1 网上，有很多教程，比我写的好的大有人在，所以，我不和他们比。
那么，为什么又写这样的帖子，初心：实践出真知。
书是给会的人看的。写这些东西，第一是复习，第二是实践。
我准备加快节奏，尽快进入自己的领域。
2 纯代码解说，复习，学习。
变量的作用域
# include<iostream> // 引用 头文件iostream, include就是引用的意思，以后不再概述。
// # include"suibian.h" 看到★后将他取消 // 注释符
using namespace std; // 使用 命名空间 std， 就是我要这工具库里所有的东西。
int main()
{
int a = 100; // 定义a, 初始化为100.
{
int a = 2; // 定义a, 初始化为2.
cout << "a = " << a;
//问题来了，我定义了两个a,电脑知道我要用哪个吗？
// 答案是 a = 2. 为什么？
// 因为电脑才不管你要哪个，就近原则。
// 这里“{}”中括号啥意识，前面说了，就是火车头和火车尾，也就是我在火车里面套了个火车，我找a，它不会去找外面的a。
}
cout << "a = " << a;
// 结果是 a = 100。
// 为什么。
// 因为“{}”中括号里的a，寿命到头了，你盒子里面包着盒子，人家不想拆，面前就有一个a，就找它。
int b = 200;
{
cout << "b = " << 200;
//结果是b = 200
//为什么？
//因为人家发现在盒子里面找不到b, 所以跑到外面去找，那么反过来行不行？思考
}
{
int c = 300;
}
// cout << "c = " << c;
// 很显然，答案是不行，简单说，这c是个奴隶（吠舍）！它只能在地里老老实实干活，想出来，门都没有。
// 那么又一个问题，别的文件的c 能不能找到，在别的地方，他可能不在这。
// 答案是能， 有前提，前提是，你得说明他在哪个文件，那个命名空间。
// 比如下面 ★ ，VS右侧在头文件文件夹，新建头文件，suibian.h，在该文件下，写上int c = 300;
// cout << "c = " << c;
}

常量、静态修饰符， 循环和函数声明及定义
//编程头信息：
//------------------------------------------------------
//--文件：*********
//--作者：某某人
//-- 邮箱：不能说
//-- 功能：*********
//------------------------------------------------------
#include <iostream>
using namespace std;
#define LENGTH 10; //#define 为预处理器 可用于定义常量。
#define WIDTH 5;
void func(void); //这里写了一个函数的声明，也就是告诉电脑有这么个东西。
void func2(void);
static int test_count_1 = 5;
int main()
{
int a = 1;
const int len = 100; // 前面加const 为常量修饰，定以后len不可再次修改。
while (test_count_1--) //while 循环 ()括号内如果为true值也就是不等于0时，会一直循环{}的内容
{
func();
}
cout << "------------对照组1--------------" << endl;
test_count_1 = 5;
while (test_count_1--)
{
func();
}
cout << "------------对照组2--------------" << endl;
test_count_1 = 5;
while (test_count_1--)
{
func2();
}
cout << "-------------对照组3-------------" << endl;
test_count_1 = 5;
while (test_count_1--)
{
func2();
}
// 结合下文，两组相同的代码，static int 和 int 相差一个修饰符，结果却完全不同。
// static 的效果为在程序生命周期内，保持此变量存在，不会在进入和离开时，重新创建和销毁，因此func 里的i,是同一个内存地址，而func2每次都会被回收，重建。
return 0;
}
// 函数实现，就是增加了{}里的内容，告诉电脑这是干什么用的。
void func(void)
{
static int i = 0;
i++;
cout << "i = " << i << endl;
cout << "test_count_1 = " << test_count_1 << endl;
}
void func2(void)
{
int a = 0;
a++;
cout << "a = " << a << endl;
cout << "test_count_1 = " << test_count_1 << endl;
}

运算符
//编程头信息：
//------------------------------------------------------
//--文件：运算符
//--作者：某某人
//-- 邮箱：不能说
//-- 功能：*********
//------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20;
int c;
c = a + b;
cout << "c = " << c << endl;
c = a - b;
cout << "c = " << c << endl;
c = a * b; //*表示乘法
cout << "c = " << c << endl;
c = a / b; // /表示除法 请记得小数点非浮点则阶段，故为0
cout << "c = " << c << endl;
c = a % b; // % 表示取余
cout << "c = " << c << endl;
c = a++; // ++ 同 a = a + 1;
cout << "c = " << c << endl;
c = a--; // -- 同 a = a - 1;
cout << "c = " << c << endl;
// 判断语句 如果（括号内相等）则 执行{a} 否则 {b}
if (0 == a + b) // == 是 两边比较是否对等，而=是赋值，不是正常熟知等于。
{
cout << "他不会进来的，因为a+b == 30" << endl;
}
else
{
cout << "他只会来我这里，你这个坏孩子。" << endl;
}
bool flag = false;
flag = (0 != a + b); // 不等于
cout << "flag = " << flag << endl;
flag = (30 == a + b); // 等于
cout << "flag = " << flag << endl;
flag = (30 >= a + b);
cout << "flag = " << flag << endl;
flag = (30 <= a + b);
cout << "flag = " << flag << endl;
flag = (30 > a + b);
cout << "flag = " << flag << endl;
flag = (30 < a + b);
cout << "flag = " << flag << endl;
return 0;
}

循环，判断
#include <iostream>
using namespace std;
int main()
{
// 循环， for(init;condition;increment), init可以什么都不写，它首先会被执行一次。
// condition如果为true则继续执行里面的内容，执行{}内后，再执行increment.
for (int i = 0; i < 10; i++)
{
cout << "i = " << i << endl;
}
int a = 0;
while (true)
{
a++;
if (3 <= a)
{
break; // 如果再循环体内，或者再循环体的if里，会跳出此层循环。
}
else if (a == 2)
{
cout << "a = 2" << endl;
}
else
{
cout << "a != 2" << endl;
}
}
int b = 0;
while (3 > b)
{
b++;
// switch 用以判断括号内的参数，效果其实和if差不懂。
switch (b)
{
case 1:
continue; // 强制进入下一次循环。注意： 循环内，下面的内容不会继续执行。
default:
cout << "b = " << b << endl;
break; // 在switch 则立即跳出其他case的判断。 和上面的if做区分，
}
cout << "------------------" << endl;
}
return 0;
}

函数、数组、字符串
#include <iostream>
#include<string>
using namespace std;
// 函数定义形式如下
// return_type function_name(parameter list)
// { body of the function }
int max(int num_1, int num_2);
int main()
{
cout << "1 和 2谁比较大？ 答案：" << max(1, 2) << endl;
// 声明数组 形式为：type arrayName[arraySize]; 翻译 变量类型 数组名[数组多少个]
float a[3] = { 1.1f,2.1f,3.1f };
float b[] = {4.2f,5.2f};
cout << sizeof(a) / sizeof(a[0]) << endl;
cout << sizeof(b) / sizeof(b[0]) << endl;
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
printf("a[%d] = %f, \n", i, a[i]);
}
char zi[] = {'c','+','+'};
for (auto c : zi)
{
cout << c;
}
cout << endl;
return 0;
}
int max(int num_1, int num_2)
{
return num_1 < num_2 ? num_2 : num_1; // 翻译 ： 如果 num_1 小于 num_2 则 num_2 否则 num_1。
}

指针
//编程头信息：
//------------------------------------------------------
//--文件：指针
//--作者：某某人
//-- 邮箱：不能说
//-- 功能：*********
//------------------------------------------------------
#include <iostream>
#include<string>
using namespace std;
void max(int, int,int&);
int main()
{
int i, & ri = i; // &引用，相当于给赋值的变量取了另外的名字。
i = 5; ri = 10;
printf("i = %d, ri = %d\n", i, ri);
int maxNum;
//引用可用于函数中，将变量传递进入函数，被传入后，如果函数内部有修改该变量，则该变量被修改。
max(100, 123, maxNum);
printf("maxNum = %d\n", maxNum);
//指针:指针是一个对象，可以对指针拷贝和赋值。
int* p1, * p2 = NULL;
int ival = 23;
p1 = &ival; // 注意什么类型的赋值给什么， int 给 int*，double 给 double.翻译，将p1指向ival的内存地址。
*p1 = 66;
cout << "p1 指向地址为：" << p1 << " p1 值为：" << *p1 << endl;
cout << "ival 地址为：" << &ival << " ival 值为：" << ival << endl;
cout << "p1 的地址为：" << &p1 << endl; //
//让人头大的类型如下，指向指针的指针。
int** pp1 = &p1;
**pp1 = 55;
// 相信我，别这么搞，指向指针的指针令人头大，指向指向指针的指针令人爆炸。
cout << "p1 指向地址为：" << p1 << " p1 值为：" << *p1 << endl;
cout << "pp1 指向地址为：" << pp1 << " pp1 值为：" << **pp1 << endl;
cout << "ival 地址为：" << &ival << " ival 值为：" << ival << endl;
// 又有引用，又有指针怎么去理解
int a = 88;
int* p = &a;
int*& r = p;
// 从右向左阅读，首先是引用， 然后int* 其实是连在一起的，表示这是一个int类型指针。
// 合并阅读，引用int指针， 所以 r 是 p 的另外一个名字。
cout << *r << endl;
return 0;
}
void max(int a, int b, int& maxNum)
{
maxNum = a < b ? b : a;
}

数据结构
头文件内容
#ifndef SUIBIAN_H
#define SUIBIAN_H
#include<string>
struct Hero // 爱定多少变量定多少
{
int mp;
int hp;
std::string name;
};
#endif // SUIBIAN_H
//cpp内容
#include <iostream>
#include"suibian.h"
using namespace std;
int main()
{
Hero my = {100, 100, "张无忌"};
printf("%d,%d,%s", my.hp, my.mp, my.name.c_str());
return 0;
}

// 这里面我挑了类最头大的一部分，就是拷贝和重载赋值，如果再遇到申请变量会怎样。
#include <iostream>
using namespace std;
class Car
{
private:
string color;
public:
string engine;
int* p;
void setColor(string col);
void setEngine(string eng);
Car()
{
cout << "1" << endl;
this->p = new int(3);
}
//所有构造函数，都是在声明定义时调用的，需要时刻记住这一点。
Car(string col, string eng)
{
cout << "2" << endl;
color = col;
engine = eng;
this->p = new int(3);
}
Car(const Car& car);
void operator=(const Car& car)
{
cout << "我调用的是重载，而非拷贝构造。" << endl;
this->color = car.color;
this->engine = car.engine;
this->p = new int(3);
}
~Car()
{
cout << "我被释放了" << endl;
if (p != NULL)
{
delete p;
}
}
// 这里友元函数我就不说什么，只有一点需要注意，就是如果参数非引用
// 而是Car car那他就是会重新制造一个Car，这样很不好，消耗资源又多。
friend void printColor(Car& car);
};
void printColor(Car& car)
{
cout << car.color << endl;
}
Car::Car(const Car& car)
{
cout << "3" << endl;
this->color = car.color;
this->engine = car.engine;
this->p = new int(3);
}
void Car::setColor(string col)
{
this->color = col;
}
void Car::setEngine(string eng)
{
this->engine = eng;
}
int main()
{
Car car_1;
car_1.setColor( "红色");
// 这里会调用拷贝构造，因为它是刚刚定义出来的。翻译过来就是：拷贝一份car_1；
Car car_2 = car_1;
cout << car_1.p << endl;
cout << car_2.p << endl;
printColor(car_2);
int* p = new int(3);
delete p;
Car car_3;
// 这里调用的是重载函数,因为它已经经历过了构造期。翻译：将car_1的值赋值给car_3;
car_3 = car_1;
return 0;
}

// 算吧，先就简单的过了，后面再《数据结构》《程序数学》慢慢补，不急，然后，嗯，就是实战
// 下面是类的继承，重载。
#include<iostream>
using namespace std;
class People
{
public:
void eat();
void sleep();
//static Child shenghaizi(Man man, Woman)
//{
//cout << "生孩子咯" << endl;
//Child child = Child();
//return child;
//}
};
// 建议不要使用多继承，我这里的public Man 是个错误的演示，实践中，千万千万要注意，继承一个就顶天了，脑袋会
// 爆炸的！
class Child :public People, public Man
{
public:
void SayMyChild()
{
cout << "我是一个小孩！" << endl;
}
};
class Man:public People
{
public:
void SayMyMan()
{
cout << "我是一个男人" << endl;
}
void SayMyMan(bool is_strong)
{
cout << "我是一个强壮的男人" << endl;
}
// --------------------------- 重载了+号， 有将+重载了如何男人和男人 ------------------------------
Child operator+(const Man& man)
{
cout << "我们只能领养一个娃了！" << endl;
Child child = Child();
return child;
}
};
class Woman :public People
{
public:
void SayMyWoman()
{
cout << "我是一个女人" << endl;
}
};
void People::eat()
{
cout << "饭好好吃！" << endl;
}
void People::sleep()
{
cout << "该睡觉了！" << endl;
}
int main()
{
// ------------------------------ 继承 ----------------------------------
Woman a_woman;
a_woman.eat();
a_woman.sleep();
a_woman.SayMyWoman();
Man a_man;
a_man.eat();
a_man.sleep();
a_man.SayMyMan();
Child a_child;
a_child.People::eat();
a_child.SayMyChild();
a_child.SayMyMan();
// ------------------------------ 重载 --------------------------------------
a_man.SayMyMan(true);
Child child_2 = a_man + a_man;
return 0;
}
//明天弄虚表，聊聊多态。

#include<iostream>
using namespace std;
class Base
{
public:
virtual void print()
{
cout << "我是基类！" << endl;
}
void Say()
{
cout << "什么都没有！" << endl;
}
};
class Mao:public Base
{
public:
void print()
{
cout << "我是猫！" << endl;
}
void Say()
{
cout << "喵喵喵！" << endl;
}
};
class Gou:public Base
{
public:
void print()
{
cout << "我是狗！" << endl;
}
void Say()
{
cout << "汪汪汪！" << endl;
}
};
int main()
{
Base *base;
Mao mao;
Gou gou;
base = &mao;
base->print();
base = &gou;
base->print();
base->Say();
return 0;
}

C++ 呀，模板黑魔法脑壳痛