尽管教主说除了那些成绩十分不像话的，经过他的处理基本都能及格。但是我这种上课从来不听的坏孩子还是很方的有木有！（码字好累）

一、C++的初步认识

1、对C语言的增强体现在两个方面：

1）在原来基于过程机制的基础上，对C语言的功能做了不少补充。
2）增加了面向对象的机制。

2、一个简单的程序

<code>#include<iostream>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
cout<<"a+b = "<< a+b<< endl;
return 0;
}</code>

”#include<iostream>“不是C++的语句，而是C++的一个预处理指令，行的末尾没有分号。
using namespace std; 的意思是”使用命名空间std“。
cin为输入流对象，“>>”为提取运算符。
cout为输出流对象，“<<”为插入运算符，语句以分号结束。
endl表示本行结束。

3、关于注释

注释是给人看的，不是给机器看的。
注释可以用”//“来注释一行，作简短注释。
也可以以“/+星号”开始“星号+/”结束来注释几行，作长注释。
给函数和程序写注释是一个非常好的习惯。
ps：课程设计由于好多函数没有写注释，第二天再看的时候一脸懵逼TvT。

4、C++程序的构成和书写方式

1）一个C++程序可以由一个或多个程序单位构成。
2）在一个程序单位中，包含以下三个部分
①预处理指令
②全局声明部分
③函数，一个程序有且只能有一个主函数。
3）一个函数有两部分构成
①函数首部，包括函数名、函数类型、函数属性、函数参数名、参数类型。
e.g：<code>int max(int x,int y)</code>
②函数体：一般包括局部声明部分和执行部分
4）语句也包括两类：
①声明语句：不引起实际的操作，属于非执行语句。
②执行语句：用来实现用户的操作。
5）一个C++程序总是从main函数开始执行的。
6）类（class）是C++新增加的重要数据类型（面向对象）。
p.s：写课程设计的时候由于主函数少了对象而找了半天的BUG。没有对象，活该单身。

二、数据的存储、表示形式和基本运算

1、C++的数据类型

|数据类型|||||
| ------------- |:-------------:| -----:|----|
| 基本类型| 整型【长整型：long int】【短整型：short int】【整型：int】| 字符型【char】 |浮点型【单精度型：float】【双精度型：double】【长双精度型：long double】|布尔型【bool】|
| 派生类型| 指针类型【*】| 枚举类型【enum】|数组类型【[]】|结构体类型【struct】共用体类型【union】类类型【class】|
|空类型【void】||||||
p.s：markdown的表格还挺智能。。。。如果能加思维导图就更好了。

2、数据类型的范围【★★★★★】

|数据类型的数值范围|||
|-----------|:----------------:|-------:|-------------|
|类型|类型标识符|字节数【★】|
|整型【★】|【signed】int|4|
|无符号整数|【unsigned】int|4|
|短整型|【short】int|2|
|无符号短整型|【unsign short】int|2|
|长整型【★】|【long】int|4|
|无符号长整型|【unsigned long】int|4|
|字符型|【signed】char|1|
|无符号字符型|【unsigned】char|1|
|单精度型【★】|float|4|
|双精度型【★】|double|8|
|长双精度型【★】|long double|8|
p.s:刷oj的时候测试大数据会出现很多稀奇古怪的结果，但是程序的逻辑正确，oj却提示答案错误，就是因为使用int类型发生了溢出。这时候往往使用unsigned long或者unsigned long long。

3、常量

1）什么是常量：常量分为两大类，数值型常量和字符型常量。
2）数值常量:
①常量的类型：常量无unsigned 型。但一个非负整数可以赋值给unsigned型变量。前提是不会溢出。
②一个整型常量可以用三种方法表示：
Ⅰ十进制整数：如1357，-432.0等。在一个整数常量后面加一个字母l或者L则认为是long int 型变量
Ⅱ八进制整数:在常数的开头加一个0，表示八进制整数如020为（20）8，相当于十进制的16.
Ⅲ十六进制整数：在常数的开头加一个数字0和一个X或者x。如0X20表示十六禁止的20，即十进制的32.
2）浮点数的表示法
一个浮点数可以用两种不同的形式表示：
①十进制小数形式：由整数和小数部分组成，可以省略其中之一但是不能都省略（78. ， .06 ， .0）。C++在编译时将其作为双精度常量处理，占八个字节。如果数后面加上F或f则按单精度类型处理如43F，43f。如果加字母L或l则按长双精度处理占12个字节【vs中占8字节】
②指数形式：如3.14159可写成0.314159×10^{1，3.14159×10}0,31.4159×10^-1。在程序中表示为0.314159e1，3.14159e0，31.4159e-1。e后的数表示以10为底的多少次幂。
p.s：这就是浮点的由来【小数点浮动位置不固定】
4）字符常量
①普通的字符常量如：'a','@','#'等
字符常量只能包括一个字符'ab'不合法
字符常量区分大小写
cout<<'a';的结果是a而不是'a'；
②转义字符常量【★★★】

5）字符类型在内存中的存储形式和使用方法
字符在内存中以ASCII码值存储。也可以对字符数据进行算术运算。
e.g:
<code>#include<iostream>
using namespace std;
int main()
{
int i,j;
i='A';
j='B';
cout<< i << j;
return 0;
}
output：65 66
</code>
输出的结果为ASCII码值。
字符数据只占一个字节，只能存放0~255范围内的整数。
5）字符串常量
用双撇号括起来，如"FK U"
【★】"FK U" 占7个字节分别为F,,K,空格，”\0“；
因为编译系统会在字符串的末尾加上‘\0’作为结束的标志。
辨析'a'和"a"
<code>
char c//定义一个字符变量
c='a';//正确
c="a"://错误，发生溢出，c只能容纳一个字符。
</code>
6）符号常量
e.g:
<code>#include<iostream>
using namespace std;
<code>#define PRICE 30//注意这不是语句，末尾无分号
int main()
{
int num,total;
num=10;
total=num*PRICE;
cout<<"total= "<< total<< endl;
return 0;
}
</code></code>
预处理指令表示的是替换，符号常量虽然有名字但是并不是变量，如果使用赋值语句PRICE=30是错误的。
好处就是：含义清楚，一次修改能替换所有值。

4、变量

1）注意区分变量名和变量值，如a=3；则变量名为a，值为3.
2）变量名的规则：
C++中区分大小写，变量名中不能出现和关键字、系统函数名和类名相同。
命名方法有很多种驼峰，匈牙利命名法等等。
p.s:变量的命名也是十分重要，经常睡了一觉之后会看不懂自己的命名=v=。
3）定义变量
定义变量的一般形式为：
数据类型 变量名表列（就是一个或者多个变量名）
例如 int I,love,u;
为三个整型变量I，love和u。
4）C++这么规定的好处
①如果定义中为int student；
但是在后面执行语句中错写为 sutdent=30；
编译器会以sutdent没有定义报错。
②方便编译器分配内存。
③便于在便宜时检查运算是否合法。
5）对变量赋初值（变量的初始化）
可以在定义时便初始化 int a=20；
也可以先定义再初始化 int a；
a=20；
6）常变量
定义变量时加上关键字const，则变量值在运行期间不能改变。
const int a=3；
【常变量不能被赋值】
const int a；
a=20；
错误
常变量又称只读变量。
7）C++的运算符【★】
①算术运算符
"+"" -" "星号" "/" "%（整除求余） “++”（自加） “--”（自减）
②关系运算符
“<” “==”(等于) “>=”(大于或等于) “<=”(小于或等于) “！=”（不等于）
③逻辑运算符
”&&“（逻辑与【且】） “||”（逻辑或） ”！“（逻辑非）
④位运算符
“<<”(按位左移) “>>"(按位右移) "&"（按位与） "|"（按位或） "^"（按位异或） "-"（按位取反）
p.s：左移右移可看为乘二除二，一定不要把^当成次幂来用
⑤赋值运算符=
⑥条件运算符【★】？ ： （a>b）? a=0:b=0; a是否大于b，若为真则a=0，否则的话b=0
⑦指针运算符【★】<code> * </code>
⑧逗号运算符【★】，
⑨引用运算符和地址运算符【★】&
⑩求字节数运算符【★★】sizeof
⑪强制类型转换符（（类型）或类型（））
⑫成员运算符 .
⑬指向成员运算符（->）
⑭下标运算符([])
⑮其他运算符（）
8）基本的算术运算符
整数和整数相除的结果为整数部分
所以如果想得到浮点数应该将整数写作浮点形式如1->1.0;
如果基本运算中有一个数据为float数据那么运算结果为double型，C++运算时将所有float数据都作double类型处理。
9）算术表达式的优先级和结合性
优先级与小学数学课本优先级类似，结合性为左结合性。
10）不同类型数据之间的运算
转换成同一类型（最长的那一个）
11）自增自减运算【★】
++i（在使用i之前先将i的值加一）
--i （在使用i之前先将i的值减一）
i++（使用i之后将i的值增加一）
i--（使用i之后将i的值减一）
12）类型强转
（double）a
（int）（x+y）
（float）（5%3）
打字好累，不解释了，能看懂的
13）赋值过程中的类型转换
如 int a=7.13；
或 float a；
double b=7.13；
a=b；（在不发生溢出的前提下进行强转）。
14）复合赋值运算符
a+=3等价于a=a+3
x×=y+8等价于x=x×（y+8）
x%=3等价于x=x%3
C++可使用一下几种复合运算符
+= -= ×= /= %= <<= >>= &= ^= |=
15)赋值表达式
右赋给左，没什么好说的
16）逗号运算符和逗号表达式【★】
表达式1，表达式2
逗号表达式的求解过程为：先求解表达式1，再求解表达式2，整个逗号表达式的值为表达式2的值。
如：a=3×5，a×4；结果为60（没有什么异议）
如果再这里面混入复合赋值运算符和自加自减运算符就会有很多人麻爪了
p.s：不知道麻爪是哪里的方言，教主挺喜欢说的，有知道的吗？

三、基于过程的程序设计

1、算法的表示

①自然语言②流程图③伪代码④计算机语言

2、C++程序结构和C++语句

虽然谭书写的浅显易懂但是重复的部分挺多的，这一部分和前面的重复，唯一有用的部分就是定义了全局声明。
变量的寿命就是在一对花括号之间，全局变量的寿命是最长的，函数内或者循环语句内的局部变量寿命只在一对花括号之间。

3、执行语句

①if（）_else 条件选择语句
②for（）~ 循环语句
③while()~ 循环语句
④do~while（）循环语句
⑤continue 结束本次循环语句
⑥break中止循环或者switc case语句
⑦switch多分枝选择语句
⑧goto转向语句
⑨return 从函数返回语句
上表中（）表示判断条件，~表示内嵌语句
p.s:之前教主安利过goto之后，就看到国外大牛曾经发表过goto有害论，但是goto确实是一个很好用的东西，配合条件选择语句能减少很多代码量（虽然是直接复制的）。

4、C++的输入输出

C++的输入输出是通过I/O库中的输入输出函数实现的。
C++的输入输出是用“流”（stream）的方式来实现的。
键盘→“hello”→cin→>>(提取)→计算机指定的变量
“hello”→<<(插入)→cout→显示器
cin和cout是流对象，包含在stream中。
由此可见，C++的输入输出是包含在库函数中而if等C++本身提供的语句并不需要头文件iostream的包含。

5、在标准输入输出中使用控制符

p.s:如果要求保留小数时不自动进位，需要化成整数再保留有效数字。
使用输出控制符，需要头文件iomanip。

6、使用getchar和putchar进行输入输出

1）putchar函数：字符输出函数
输出字符变量的值。
2）getchar函数：此函数的作用是从终端输入一个字符，此函数没有参数。
e.g:
<code>#include<iostream>
using namespace std;
int main()
{
char c;
c=getchar();
putchar(c+32);putchar('\n')
return 0;
}</code>
input：a
output：A
注意：cout<<getchar();输出的为ASCII码值。

7、使用scanf和printf进行输入输出

scanf的输入格式为scanf（格式控制，输入表列）
printf的输出格式为printf（格式控制，输出表列）
p.s：感觉c的输入输出方式挺麻烦的，所以自己很少用，明白什么意思能看懂程序就够了。

8、关系运算与关系表达式

高优先级：< <= > >=
低优先级：== ！=

9、逻辑常量与逻辑变量

逻辑常量只有两个fale和true。
逻辑型变量需要用标识bool来定义，它的值只能是true和false之一。
逻辑型变量又称布尔变量。

10、逻辑运算与逻辑表达式

且或非在上面提到过。最经典的就是闰年的判断。

11、12、13

省略了，无非是选择语句和for、while、do-while循环。
p.s:有心情了再补上几个例子，累了睡觉。
***---
补上选择语句和循环结构的程序：
选择语句->if
<code>#include<iostream>
using namespace std;
int main()
{
int year;
bool leap;
cout<<"Please enter year"<<endl;
cin>>year;
if(year%4==0)
{if(year%100==0)
{if(year%400==0)
leap=true;
else leap=false;
}
else leap=true;
}
else leap=false;
}
else leap=false;
if(leap) cout<< year<< "is";
else cout<< year << "is not";
cout<< " a leap year"<< endl;
return 0;
}</code>
循环结构->while
<code>#include<iostream>
using namespace std;
int main()
{
int i=1,sum=0;
while(i<=100)
{
sum=sum+i;
i++;
cout<< "sum= "<< sum<< endl;
}
return 0;
}
output：sum=5050</code>
do-while
<code>#include<iostream>
using namespace std;
int main()
{
int i=1,sum=0;
do
{
sum=sum+i;
i++;
}while(i<=100)
cout<< "sum="<< sum<< endl;
return 0;
}
output:sum=5050</code>
for循环
<code>#include<iostream>
using namespace std;
int main()
{
int sum=0;
for(int i=0;i<=100;i++)
{
sum=sum+i;
}
cout<< "sum="<< sum<< endl;
return 0;
}
output:sum=5050</code>
continue：结束本次循环进入下一次循环。
break：跳出循环结构，执行下一个代码块。

四、利用函数实现制定功能

1、什么是函数

函数（function），原意为功能，那么一个函数就是一个功能。
p.s:在学习php的过程中，php使用function定义函数。

2、函数的分类

1）系统函数，即库函数
2）用户自己定义的函数
①无参函数：调用函数时不必给出参数。
②有参函数：调用时要给出参数。

3、定义函数的一般形式

类型名 函数名
{
声明部分
执行语句
}

4、形参与实参【★★★★★】

1）在定义函数时，函数名后面括号中的变量名称为形式参数。
主函数中调用函数时被调用函数函数名后面括号中的参数为实际参数。
2）有关形参和实参【★★★】
①未出现函数调用时，形式参数并没有被分配内存空间，只有发生函数调用时才被分配内存，调用结束后所占内存被释放。
②实参可以是变量常量或表达式
③定义函数时必须在函数首部指定形参类型。
④实参与实参应该类型相同或兼容
⑤实参对形参的数据传递为单向传递，只能由实参传给形参而不能回传。即调用结束后，实参的值没有发生变化。|

5、函数的返回值

通过函数的调用使调用函数的语句能得到一个确定的值，这就是函数的返回值。
【我的理解就是执行函数之后得到的值，也就是一系列运算之后的结果】
返回值通过return 语句实现，return后可以是常量、变量、甚至是表达式。
函数类型决定函数返回值的类型（不符合时发生类型强转）。

6、函数的调用

1）函数在调用发生之前要完成函数的声明【使编译器得以正常运行】
2）函数的定义和函数的声明不是一回事。
函数的定义是指函数功能的确立，包括指定函数名、函数类型、参数类型以及返回值。
函数的声明是把函数的名字、类型、参数的类型和个数告知编译器，让编译器对调用函数和定义时做检查，避免错误。
函数声明成为函数原型，作用主要是：根据函数原型在程序编译阶段对调用函数的合法性进行全面的检查。
p.s：函数的定义可以在函数调用前和函数调用后，如果发生在函数调用之前，则可以省去函数的声明。

7、函数的嵌套调用

在函数中套用相同函数；
e.g:很容易就能写出两个数或者三个数之间的求max函数，如果面对四个甚至五个数求最大值问题，可以使用函数套用的方式：
m=max（a,b）；
m=max（m,c）；
m=max（m,d）；

8、函数的递归调用

1）在调用函数的过程中又出现直接或间接地调用函数本身，称为函数的递归。
p.s：函数递归的典型问题就是汉诺塔问题以及斐波那契数列问题。
直接贴别人的博客地址，里面有详解。
http://blog.csdn.net/yafei450225664/article/details/8647908