C++要领#

#扩展名#

常见的有C、c、cxx、cpp、c++等，注意，UNIX区分大小写，这意味着应使用大写的C字符。实际上，小写c扩展名也有效，但标准C才使用小写的c。因此，为避免在UNIX系统上发生混淆，对于C程序应使用c，而对于C++程序则请使用C。如果不在乎多输入一两个字符，则对于某些UNIX系统，也可以使用扩展名cc和cxx

# 注释#

1
// 单行注释
2
/*
3
  多行注释
4
*/

# 函数#

函数使用前先声明，或者include头文件

1
#include <iostream>// 使用cin和cout必须包含
2
#include <cmath>
3

4
int main() {
5
    using namespace std;// 名称命名空间
6
/*
7
  using std::cin;
8
  using std::cout;
9
    using std::endl;  效果等同
10
*/
11

12
/*
13
   std::cout << "abc" << site << " feet to the side." << std::endl;  效果等同
14
*/
15
    double area;
16
    cout << "enter the floor area, in square feet,of your home:";
17
    cin >> area;
18
    double site = sqrt(area);
19
    cout << "that's th equivalent of a square " << site << " feet to the side." << endl;
20
    cout << "how fascinating" << endl;
21

22
    return 0;
23
}

C++能够使用printf( )、scanf( )和其他所有标准C输入和输出函数，只需要包含常规C语言的stdio.h文件。C++的输入工具它们在C版本的基础上作了很多改进。

# 简单变量#

# 整型#

short、int、long、longlong、unsigned系列

1
#include <iostream>
2
#include <climits>
3

4
int main() {
5
    using namespace std;
6
    int n_int = INT_MAX;
7
    short n_short = SHRT_MAX;
8
    long n_long = LONG_MAX;
9
    long long n_llong = LLONG_MAX;
10

11
    cout << sizeof(int) << " bytes" << endl;
12
    cout << sizeof(short) << " bytes" << endl;
13
    cout << sizeof(long) << " bytes" << endl;
14
    cout << sizeof(long long) << " bytes" << endl;
15
    cout << "Max values" << endl;
16
    cout << n_int << endl;
17
    cout << n_short << endl;
18
    cout << n_long << endl;
19
    cout << n_llong << endl;
20

21
    return 0;
22
}
23
/*
24
4 bytes
25
2 bytes
26
4 bytes
27
8 bytes
28
Max values
29
2147483647
30
32767
31
2147483647
32
9223372036854775807
33
*/

确定常量的类型

1
cout << "year = " << 1492 << "\n";// 默认int存储1492

char：特殊的整型

# 字符和字符串#

'a'是字符

"a"是字符串

# 布尔类型#

布尔转为整型

1
int ans = true; // 赋值为1
2
int ans = true; // 赋值为1

整型转为布尔

1
bool start = -100;// true
2
bool stop = 0;// false

# const 限定符#

1
const int Months = 12;// 定义时候就得初始化

Months变成了只读变量，即使常量

相比#define好在知道指定了类型，且限定作用域内起作用

# 特殊初始化语法#

区别于 C 语言的初始化方法

1
#include <iostream>
2
#include <climits>
3

4
int main() {
5
    using namespace std;
6
    int a = 100;
7
    cout << a << endl;
8
    int b(10);
9
    cout << b << endl;
10
    int c{1};
11
    cout << c << endl;
12
    return 0;
13
}

# 类型转换#

# 类型转换的规则#

{}是列表初始化，不允许缩窄（）

在计算表达式，会进行int提升（bool、char等转换成int）

小范围和大范围运算会转为大范围

强制类型转换：

1
(long) a // 强制转换类型1，临时作用 --C语言风格
2
long (a) // -- C++风格
3
static_cast<long> (a) // --强制类型转换形式2

# 自动判断类型 auto声明#

1
auto n = 100; // int
2
auto a = 1.0; // double
3
autp y = 1.3e12L; // long double

# 数组#

# 三要素#

每个元素的类型
数组名
元素数量

# 声明#

1
short mouth [12];

其中12元素数量必须已知，不可为变量（但是可以const int Size声明常量）

# 初始化规则#

只能在定义数组的时候初始化，可以少于数组数目

1
int cards[4] = {3,6,8}; // 允许，序号3元素为0
2
int bards[] = {3,6,8}; // 允许，有三个元素
3
/*
4
int hards[4];
5
hards[4] = {3,6,7,8}; -- 不允许
6
hards = cards; -- 不允许
7
*/

可以单个元素赋值

1
cards[1] = 3;

C++11中=可省略

1
int bards[] {3,6,8};

{}列表初始化，不允许缩窄

1
char mards[] = {32342344,6,8}; // 32342344超出范围

# 计算数组的元素个数#

1
int count = sizeof(a) / sizeof((a[0]));

解释：sizeof(a) 返回数组 a 在内存中的总字节数，sizeof(a[0]) 返回数组 a 中第一个元素的字节数。

字符串的话/0也会计算进去

# 字符串#

字符串是以\0结尾的数组

1
char cat[] = {'f','a','t','e','s','s','a','\0'};
2
char fish[] = "Bubbles";

注意：'' 表示字符，""表示字符串，不可互换

空白自动拼接两字符串

strlen()计算字符串长度（没有\0），区分sizeof()

# 读取字符串#

cin通过空白字符判断结束

cin.getline(name,20)放入name，读取20-1个字符 — 面向行输入（回车终止并且丢弃回车）

cin.get(name,20)放入name，读取20-1个字符 — 面向行输入（回车终止并且保留回车，无法跨越回车）

1
cin.get(name,20);// 不可处理回车
2
cin.get();// 可处理回车
3

4
cin.get(name,20).get();// 写法2处理回车
5

6
cin.clear();// 复位失效位

# string 类#

1
#include <iostream>
2
#include <string>
3

4
int main(){
5
  using namespace std;
6
  char charr1[20];
7
  char charr2[20] = "jaguar";
8
  string str1;
9
  string str2; = "panther";
10
  cout << "Enter another kind of feline:";
11
  cin >> charr1;
12
  cout << "Enter another kind of feline:";
13
  cin >> str1;
14
  cout << "Here are some felines:\n";
15

16
  cout << charr1 << " " << charr2 << " " << str1 << " " << str2 << endl;
17

18
  cout << "The third letter in " << charr2 << "is" << charr2[2] << endl;
19
    cout << "The third letter in " << str2 << "is" << str2[2] << endl;
20

21
  return 0;
22
}

string和字符数组的处理方式相同

string会自动调节数组大小

一个string可以赋予另一个string对象

1
#include <iostream>
2
#include <string>
3
#include <cstring>
4

5
int main(){
6
  using namespace std;
7
  char charr1[20];
8
  char charr2[20] = "jaguar";
9
    string s1 = "aaa";
10
    string s2,s3;
11
    s2 = s1;
12
    cout << s2 << endl;
13
    strcpy(charr1,charr2);//charr2->charr1复制
14

15
    s3 = s1 + s2; // 字符串拼接
16
    s3 += "hahaha"; // 拼接到末尾
17
    strcat(charr1,"ccc");// 拼接到末尾
18

19
    int len1 = str1.size();//string风格计算字符
20
    int len2 = strlen(charr1);//C风格计算字符
21

22

23
  return 0;
24
}

# string 类IO#

1
#include <iostream>
2
#include <string>
3
#include <cstring>
4

5
int main(){
6
  using namespace std;
7
  char charr[20];
8
  string str;
9
  cout << "length:" << strlen(charr1) << endl; // 报错，因为计算的是到下一个\0
10
  cout << "length:" << str.size() << endl;
11

12
  cout << "Enter:\n";
13
    cin.getline(charr,20);// 对于cin来说，getline是类方法
14
  cout << "Entered: " << charr << endl;
15
     cout << "Enter:\n";
16
    getline(cin,str);// 对于string来说，getline是普通函数
17
  cout << "Entered: " << str << endl;
18
    cout << "length:" << strlen(charr1) << endl; // 报错，因为计算的是到下一个\0
19
  cout << "length:" << str.size() << endl;
20
  return 0;
21
}

cout遇到char字符串直接通过地址读内容

初始化字符串用=，其他情况用strcpy() strncpy()

1
 char animal[20] = "bear"
2
 ps = new char[strlen(animal)+1];
3
 strcpy(ps,animal);

简化输入：

using namespace std::string_literals; 允许我们直接使用s后缀来创建std::string对象，而无需写成std::string。

1
int main() {
2
    auto str = "Hello, World!"s; // 使用"s"后缀直接创建std::string对象
3
    return 0;
4
}

# 结构体#

同一个结构可以存储多个类型的数据

创建结构分两步：①定义结构描述 ②按描述创建结构变量

注意：结构内容用,隔开，结构之间;隔开，;结尾

1
#include <iostream>
2
struct inflatable
3
{
4
    char name[20];
5
    float volume;
6
    double price;
7
};
8

9
int main(){
10
    using namespace std;
11
    inflatable hat; // 声明 inflatable 类型 hat
12
    hat.volume = 10.0;// 访问 hat 的 volume 成员
13

14
    inflatable guest = {
15
        "Glorious Gloria",
16
        1.88,
17
        29.90
18
    };
19

20
    inflatable g2;
21
    g2 = guest;// 成员赋值
22
    cout << "Expand your guest list with " << guest.name << endl;
23
    cout << "Expand your guest list with " << g2.name << endl;// 成员赋值y有效
24
    return 0;
25
}

# 结构数组#

创建3个inflatable的数组：

1
#include <iostream>
2
struct inflatable
3
{
4
    char name[20];
5
    float volume;
6
    double price;
7
};
8
int main(){
9
    using namespace std;
10
    inflatable g2[2] = {
11
        {"Glorious Gloria",1.88,29.90},
12
        {"Glorious gg",1.44,29.4}
13
    };
14
    cout << "Expand your guest list with " << g2[1].name << endl;
15
    return 0;
16
}

# 共用体#

可以存储不同类型，但是使用时只能同时存储一个

1
union one4all
2
{
3
  int int_val;
4
  long long_val;
5
  double double_val;
6
};
7
//double 最大，用double开辟内存空间

用处：可以表示商品ID（用字母、汉字、数字）

1
union id
2
{
3
  long id_num;
4
  char id_char[20];
5
}

# 枚举#

1
enum spectrum{red,orange,yellow,green,blue};
2
spectrum band;
3
band = blue;
4
band = 2000;// 错误
5
int color = band + 3;//可以提升到int band为5

# 设置枚举量值#

1
enum bits{one = 1, two = 2, four = 4, eight = 8};

可以设置多个值相同的枚举

1
enum {zero,null=0};

# 取值范围#

最大枚举量值的下一个最小二次幂，再减1：7就是8-1,16就是32-1

# 指针#

*：

指针：是“指向”另外一种类型的复合类型，实现了对其他对象的间接访问。

解地址：解开某个对象的地址，获得该对象所占空间对应的值。

&：

引用：是“引用”另外一个类型的复合类型，对已经存在的对象起另外一个名字，即为别名。

取地址：获得某个对象的地址。

1
int i = 42; int &r = i; //&紧随类型名出现，r是一个引用
2
int *p; //*紧随类型名出现，p是一个指针
3
p = &r； //&出现在表达式，是一个取地址符
4
*p = i； // *出现在表达式，是一个解引用符
5
int &r2 = *p //&紧随类型名出现，r2是一个引用；*出现在表达式，是一个解引用符

总结：

*出现在声明语句时，*为复合类型指针的意思；

*出现在表达式时，*为运算符解引用的意思。

&出现在声明语句时，&为复合类型引用的意思；

&出现在表达式时，&为运算符取地址的意思。

定义：

1
int updates = 6;
2
int* p_updates = &updates;
3

4
float bb = 8.8;
5
float* p_bb= &bb;

以下都可以：

1
int* a;
2
int *a;
3
int*a;

指针赋值

1
long* fellow;
2
*fellow = 123;
3
//非法，fellow指向了不知道哪里的地址
4
int * pt;
5
pt = (int*) 0xB8000000;// 强制转换

# new 分配内存，delete 释放内存#

开辟一个int类型的空间给pn指针

1
int* pn = new int;

new开辟的内存会一直存在，应该使用delete删除

1
int* ps = new int;
2
delete ps;

delete分配的内存删除，但是指针ps还在，可赋值其他内存

delete不允许删除非new创建的指针

# new 创建动态数组#

创建动态数组

1
int* psome = new int[10];// psome 是首个元素的地址
2
delete [] psome;// 释放整个数组

此时可以指针当做数组名

1
int* psome = new int[3];
2
psome[0]= 66;
3
psome[1]= 88;
4
psome[2]= 77;
5
delete [] psome;

还可以移位

1
int* p3 = new int[3];
2
p3[0]= 66;
3
p3[1]= 88;
4
p3[2]= 77;
5
p3 = p3 + 1;
6
//p3[0]= 88;p3[1]= 77;
7
p3 = p3 - 1;
8
//p3[0]= 66;p3[1]= 88;
9
delete [] p3;

sizeof不会把数组名当做地址，会当成整个数组的大小

1
#include <iostream>
2
int main()
3
{
4
    using namespace std;
5
    int stacks[3] = {3,2,1};
6
    cout << "sizeof(stacks) = " << sizeof(stacks) << endl;// sizeof(stacks) = 12
7
    cout << "stacks[0] = " << &stacks[0] << endl;// 第一个元素的地址
8
    cout << "stacks = " << stacks << endl;// 数组首位元素的地址
9
    cout << "&stacks = " << &stacks << endl;// 是整个数组的地址，地址的长度是整个数组
10
    /*
11
    stacks[0] = 0xabb59ff714
12
    stacks = 0xabb59ff714
13
    &stacks = 0xabb59ff714
14
    */
15
    return 0;
16
}

# 创建动态结构#

创建结构

1
struct things
2
{
3
  int good;
4
  int bad;
5
};

访问成员

1
things a = {3,453};
2
things* pt = &a;
3
//结构名.成员 指针->成员 访问成员的格式
4
a.good = 1;
5
pt->good = 2;
6
(*pt).good = 3;

动态调整

1
#include <iostream>
2
#include <string.h>
3
using namespace std;
4
char* getname();
5

6
int main()
7
{
8
    char* name;
9
    name = getname();
10
    cout << name << " at " << (int*)name <<endl;
11
  delete[] name;
12
    return 0;
13
}
14

15
char* getname()
16
{
17
    char temp[50];
18
    cout << "Enter your name: ";
19
    cin >> temp;
20
    char* pn = new char[strlen(temp) + 1];
21
    strcpy(pn, temp);
22
    return pn;
23
}

# 模板类 vector#

可以自动调节内存

1
#include<vector>
2

3
using namespace std;
4
vector<int> vi;//不指定长度，自动调节内存
5
vector<double> vd(n);//指定长度
6

7
// 错误：vector<double> va(3) = {1.1,2.2,3.3};
8
vector<double> va = {1.1,2.2,3.3};//正确

# 模板类 array#

长度固定，使用栈，功能和数组一样，但比数组方便安全

1
#include<array>
2

3
using namespace std;
4
array<int,5> ai;
5
array<double,4> ad = {1.2,2.1,3.3,4.4};

# 对比#

1
vector<double> va = {1.1,2.2,3.3};
2
array<double,4> ad = {1.2,2.1,3.3,4.4};
3
va = ad;// 可行，对象可以互相赋值，但是地址分开

检测有无越界：

1
a2[-2] = 5;// 错误但不检查
2
a2.at(2) = 3;// 错误但检查，捕获索引

# 循环#

作用域

1
int i = 10;// main的i
2
for (int i = 0 ; i < 5 ; i++){// 作用域内新i
3
  cout << i << endl;
4
}

1
int i;
2
for (i = 0; i < 10; i++) {// main已经声明i可以不用声明
3
    cout << i << endl;
4
}

1
int i=2;
2
for (; i < 10; i++) {//用的main的i
3
    cout << i << endl;
4
}

# 前后缀递增递减#

++i先+1 i++，就是i，再说+1

一个分号就是一个顺序点，完整表达式末尾也是顺序点

1
while (guests++ < 10)// 比较完，在顺序点（进入循环前)+1
2
  cout << guests << endl;
3
for (n=1; n > 0 ; n++)
4
    cout << n << endl;
5
// 这里两个n的++前后没有区别，运行效率略微有区别
6
for (n=1; n > 0 ; ++n)
7
    cout << n << endl;

# 语句块#

1
#include <iostream>
2

3
int main() {
4
    using namespace std;
5
    int a = 10;
6
    {
7
        int a = 100;
8
        cout << a << endl;// 显示新变量，隐藏外部变量
9
        int b = 100;// 局部变量，出局释放
10
    cout << a << endl;
11
}

# 逗号运算符#

两个运算符合并成一个

1
for (j = 0 , i = word,size() - 1;j < i ; --i , ++j)
2
{
3
  temp = word[i];
4
  word[i] = word[j];
5
  word[j] = temp;
6

7
}

# C 风格字符串比较#

1
char word[] = "mate";
2
word == "mate";// 错误，是比较两个地址是否相等
3
strcmp("mate","made");// 字符串比较，相同为0

# String 比较#

1
string word;
2
word != "mate";

# while 编写延时#

1
#include <iostream>
2
#include <ctime>
3

4
int main() {
5
    using namespace std;
6
    cout << "delay time: " ;
7
    float seconds;
8
    cin >> seconds;
9
    clock_t delay = seconds * CLOCKS_PER_SEC;// clock_t是long，类型别名方便阅读代码
10
    cout << "begining" << endl;
11
    clock_t begin = clock();
12
    while (clock() - begin < delay);
13
    cout << "done" << endl;
14
}

# 类型别名#

1
#define BYTE char
2
//全局替换所有的char为BYTE
3

4
typedef char byte;
5
typedef char* byte_pointer;
6
//直接用typedef替换
7
auto byte = 1;
8
//自动识别类型定义

# 基于范围的for循环#

遍历列表

1
double prices[5] = {22.2,33.1,4.3,5.0};
2
for (double x : prices)// x 依次表示每一个元素
3
  cout << x << endl;
4
for (double &x : prices)// 遍历引用
5
  x = x * 0.8;// 可以直接xiu'gai

# 文件尾条件（EOF）#

1
#include<iostream>
2
int main()
3
{
4
    using namespace std;
5
    char ch;
6
    int count = 0;
7
    cin.get(ch);
8
    while (cin.fail() == false)// 检测是否有EOF位
9
     // while (!cin.fail())// 简化1
10
     // while (cin.get(ch))// 简化2，返回cin转换为布尔
11
    {
12
        cout << ch;
13
        ++count;
14
        cin.get(ch);
15
    }
16
    cout << endl << count << endl;
17
    return 0;
18
}

EOF 在Windows是Ctrl+Z

重置用cin.clear()

区分有参数和无参数：

属性	cin.get(ch)	ch=cin.get()
输入字符	字符赋值给ch	函数返回值赋给ch
读取到字符	cin对象（布尔转换为true）	int类型的ASCII码
读取到EOF	cin对象（布尔转换为false）	EOF

# 二维数组和循环嵌套#

1
int maxtemps[4][5]

maxtemps[4]是数组的数组 int[5]是int的数组

	0	1	2	3	4
maxtemps[0]	maxtemps[0][0]	maxtemps[0][1]	maxtemps[0][2]	maxtemps[0][3]	maxtemps[0][4]
maxtemps[1]	maxtemps[1][0]	maxtemps[1][1]	maxtemps[1][2]	maxtemps[1][3]	maxtemps[1][4]
maxtemps[2]	maxtemps[2][0]	maxtemps[2][1]	maxtemps[2][2]	maxtemps[2][3]	maxtemps[2][4]
maxtemps[3]	maxtemps[3][0]	maxtemps[3][1]	maxtemps[3][2]	maxtemps[3][3]	maxtemps[3][4]

1
#include<iostream>
2
int main()
3
{
4
    using namespace std;
5
    int maxtemps[4][5] = {
6
        {22,33,44,55,66},
7
        {12,3666,4444,222,776},
8
        {211,331,2211,122,44},
9
        {4422,6655,3344,2252,12}
10
    };
11
    for(int i=0;i<4;i++)
12
        for(int j=0;j<5;j++)
13
            cout << maxtemps[i][j] << " ";
14
    return 0;
15
}

# 逻辑运算符#

|| ,and：或，一真为真，前真后不执行，优先级低于关系运算符

&&,or：与，一假为假，前假后不执行，优先级低于关系运算符

!,not：非，取反，优先级最高，注意加括号

# cctype库函数#

此部分出处：https://www.cnblogs.com/AlienfronNova/p/14528837.html

作者：摸鱼鱼的尛善

一、处理类#

①tolower(C)

作用：将C转换为小写字母；若不能转换，不作任何变化返回ch

参数：ch为整型

1
char str[] = "Test STRING\n";
2
char c;
3
for(int i = 0;str[i];i++){
4
    c = str[i];
5
   putchar (tolower(c));
6
}
7
//当str到最后也就是'\0'的时候，'\0'对应的就是0，放在循环里也就是代表false

②toupper(ch)

作用：将C转换为大写字母；若不能转换，不作任何变化返回ch

参数：ch为整型

1
char str[] = "tEST string\n";
2
char c;
3
for(int i = 0;str[i];i++){
4
    c = str[i];
5
   putchar (toupper(c));
6
}

二、判断类#

①isalnum(int ch)

作用:判断字符是否为数字、大写字母、小写字母。若是，返回非零的值；否则，返回0

参数：ch为整型

1
int flag = isalnum('3');
2
printf("%d",flag);

②isalpha(int ch)

作用:判断字符是否为大写字母、小写字母。若是，返回非零的值；否则，返回0

参数：ch为整型

③isupper(int ch)

作用:判断字符是否为大写字母。若是，返回非零的值；否则，返回0

参数：ch为整型

④islower(int ch)

作用:判断字符是否为小写字母。若是，返回非零的值；否则，返回0

参数：ch为整型

⑤isdigit(int ch)

作用:判断字符是否为数字。若是，返回非零的值；否则，返回0

参数：ch为整型

⑥iscntrl(int ch)

作用:判断字符是否为控制字符。若是，返回非零的值；否则，返回0

参数：ch为整型

1
printf("%d",iscntrl('\n'));

⑦isgraph(int ch)

作用:判断字符是否为图形字符（数字、大写字母、小写字母、标点字符）。若是，返回非零的值；否则，返回0

参数：ch为整型

⑧isspace(int ch)

作用:判断字符是否为空白间隔符（空格’ ‘、换页’\f’、换行’\n’、回车’\r’、水平制表’\t’、垂直制表’\v’）。若是，返回非零的值；否则，返回0

参数：ch为整型

1
/*
2
值得一提的是C语言在处理你输入的代码时
3
会忽略空白间隔符
4
包括现在写的注释也会被处理成空格

⑨isprint(int ch)

作用:判断字符是否为可打印字符（数字、字母、标点符号、空格）。若是，返回非零的值；否则，返回0

参数：ch为整型

⑩ispunct(int ch)

作用:判断字符是否为标点符号。若是，返回非零的值；否则，返回0

参数：ch为整型

# ?:运算符号#

1
表达式?为真返回值:为假返回值

# switch#

1
switch(integer-expression){// 整形
2
    case label1 : statement(s)
3
    case label2 : statement(s)
4
    default statement(s)
5
    }

注意每条选择必须加break

还可以使用枚举enum类型选择

# break 和 continue#

break：跳出循环

continue：跳过这轮循环

# 输入输出到文件#

# 输出到文件#

1
#include<iostream>
2
#include<fstream>
3

4
int main() {
5
    using namespace std;
6

7
    char ch[60];
8
    int year;
9
    double a_price;
10
    double d_price;
11

12
    ofstream outFile;// 创建实例
13
    outFile.open("carinfo.txt");// 打开文件
14
    outFile<<"Year: "<<year<<endl;// 输出到文件
15

16
    outFile.close();
17
}

open()每一次运行的时候创建一个空白的carinfo.txt替换文件

# 读取文件#

1
#include<iostream>
2
#include<fstream>
3
const int SIZE = 60;
4

5
int main() {
6
    using namespace std;
7
    char filename[SIZE];
8
    ifstream infile;
9
    cout << "Enter the name of data file: ";
10
    cin.getline(filename, SIZE);
11

12
    infile.open(filename);// 打开文件
13
    if (!infile.is_open()) // 如果没有成功打开
14
    {
15
        cout << "File could not be opened"<< filename << endl;
16
        exit(EXIT_FAILURE);
17
    }
18
    double value;
19
    double sum = 0;
20
    int counter = 0;
21

22
    infile >> value;
23
    while (infile.good())// 判断是否读取成功
24
    {
25
        ++counter;
26
        sum += value;
27
        infile >> value;
28
    }
29

30
    if (infile.eof())// 是否读到末尾
31
        cout << "End of file reached." << endl;
32
    else if (infile.fail())// 是否读取数据不匹配
33
        cout << "Input terminated by data mismatch.\n";
34
    else// 其他原因
35
        cout << "Input terminated for unknown reason." << endl;
36

37
    infile.close();// 关闭文件
38
}

# 函数#

使用函数必须完成：

函数定义
函数原型
调用函数

库函数是定义和编译好了的函数，头文件包含原型

1
#include<iostream>
2
void simple(void);// 函数的原型（声明）
3

4
int main() {
5
    using namespace std;
6
    simple();// 调用
7

8
    return 0;
9
}
10

11
void simple(void) {// 函数定义
12
    using namespace std;
13
    cout << "I'm but a simple function.\n";
14
}

# 函数和数组#

1
#include<iostream>
2
const int ArSize = 8;
3
int main() {
4
    using namespace std;
5
    int cookies[ArSize] = {1,2,4,8,16,32,64,128};
6
    sum_arr(cookies,ArSize);// 注意是数组名和数组大小
7
    return 0;
8
}
9

10
int sum_arr(int arr[ArSize], int size) {
11
// 相当于 int sum_arr(int *arr int size) {
12
    int sum = 0;
13
    for (int i = 0; i < size; i++) {
14
        sum += arr[i];
15
    }
16
    return sum;
17
}

arr[ArSize]传参相当于指针传参

传入数组要明确指出数组元素个数

# 只读指针#

如果只想只读就使用const chat* str，避免共用地址被修改的问题

指针和内容都是不可变的

# 返回字符串#

返回字符串可以返回数组地址

# string对象#

1
void display(const string* ar,int n) {
2
    for(int i = 0; i < n; i++) {
3
        cout << i+1 <<": "<<ar[i]<<endl;
4
    }
5
    display(list,SIZE);

# array对象#

1
#include<iostream>
2
#include<array>
3

4
const int Seasons = 4;
5
std::array<std::string, Seasons> SeasonNames = {"Spring","Sunmmer","Fall","Winter"};
6
void fill(std::array<double, Seasons> *pa);
7
void show(std::array<double, Seasons> da);
8
int main() {
9

10
    std::array<double, Seasons> expenses;
11
    fill(&expenses);
12
    show(expenses);
13
    return 0;
14
}
15

16
void fill(std::array<double, Seasons> *pa) {
17
    using namespace std;
18
    for (int i = 0; i < Seasons; i++) {
19
        cout << "Enter" << SeasonNames[i] << "expenses" << endl;
20
        cin >> (*pa)[i];
21
    }
22
}
23

24
void show(std::array<double, Seasons> da) {
25
    using namespace std;
26
    double total = 0.0;
27
    for (int i = 0; i < Seasons; i++) {
28
        cout << SeasonNames[i] << " " << da[i] << endl;
29
        total += da[i];
30
    }
31
    cout << total << endl;
32
}

# 递归#

包含函数自己的递归

一般需要一个条件判断语句终止

1
#include <iostream>
2
void countdown(int number);
3

4
int main() {
5
using namespace std;
6
countdown(4);
7

8
return 0;
9
}
10

11
void countdown(int number) {
12
    using namespace std;
13
    cout << "count down: " << number << endl;
14
    if (number > 0 )
15
        countdown(number - 1);
16
    cout << number << "kaboom" << endl;
17
}

# 函数指针#

获取函数地址：函数名（不加括号就是地址） 区分函数的返回值函数名（）

1
double pam(int)
2
double (*pf)(int)
3
// 当*pf指向pam，两条作用等同

一般用于函数内直接调用其他函数

1
#include <iostream>
2
double betsy(int lns) ;
3
double pam(int lns) ;
4
void estimate(int lines,double(*pf)(int));
5

6
int main() {
7
using namespace std;
8
    int code;
9
    cout << "How many lines of code do you need?";
10
    cin >> code;
11
    cout << "Here's Betsy's estimate:\n";
12
    estimate(code,betsy);// 传入besty函数
13
    cout << "Here's Pam's estimate:\n";
14
    estimate(code,pam);
15
    return code;
16

17
}
18

19
double betsy(int lns) {
20
    return 0.05 * lns;
21
}
22

23
double pam(int lns) {
24
    return 0.03 * lns + 0.0004 * lns * lns;
25
}
26

27
void estimate(int lines,double(*pf)(int)) {// 按地址读出来
28
    using namespace std;
29
    cout << lines << "lines will take" ;
30
    cout << (*pf)(lines) << "hours" << endl;
31
}

一个等式: **&pa == *pa == pa[0]

详细解释各种函数指针：

1
#include <iostream>
2

3
const double *f1(const double *ar, int n);
4

5
// const double* f1(const double ar[],int x);
6
// const double* f1(const double[],int n);
7
// const double* f1(const double*,int);
8

9
/*  四种函数原型都符合规定
10
 *  变量可以写别的名字，可以不写
11
 *  数组和地址可以互换
12
 *  只要确定函数名、返回值就行
13
 */
14

15
const double *f2(const double [], int n);
16

17
const double *f3(const double *, int n);
18

19
int main() {
20
    using namespace std;
21
    double av[3] = {1112.3, 12312.4, 123.7};
22

23
    const double * (*p1)(const double *ar, int n) = f1; //函数入口地址赋给函数指针
24
    auto p2 = f2; // 自动类型
25
    //const double* (*p2)(const double* ar,int n) = f2;等同
26

27
    cout << "Address value" << endl;
28
    cout << (*p1)(av, 3) << ":" << *(*p1)(av, 3) << endl; //f1(av,3):*(f1(av,3))____0x16d9d31b0:1112.3
29
    cout << p1(av, 3) << ":" << *p1(av, 3) << endl; //p1、*p1等价，仅限于函数指针
30
    cout << p2(av, 3) << ":" << *p2(av, 3) << endl;
31

32

33
    const double * (*pa[3])(const double *, int) = {f1, f2, f3}; //pa是三个元素的数组，内容都是函数指针
34
    auto pb = pa;
35
    //const double* (**pb)(const double*,int) = pa;等同
36
    cout << "Address value" << endl;
37
    for (int i = 0; i < 3; i++) {
38
        cout << pa[i](av, 3) << ":" << *pa[i](av, 3) << endl;
39
        cout << (*pa[i])(av, 3) << ":" << (*(*pa[i]))(av, 3) << endl; // 等效
40
    }
41
    cout << "Address value" << endl;
42
    for (int i = 0; i < 3; i++) {
43
        cout << pb[i](av, 3) << ":" << *pb[i](av, 3) << endl;
44
        cout << (*(pb[i]))(av, 3) << ":" << *((*(pb[i]))(av, 3)) << endl; // 等效
45
    }
46
    auto pc = &pa;
47
    //const double* (*(*pc)[3])(const double*,int) = &pa;等同
48
    cout << "Address value" << endl;
49
    cout << (*pc)[0](av, 3) << ":" << *(*pc)[0](av, 3) << endl;
50
    cout << (*((*pc)[0]))(av, 3) << ":" << *(*((*pc)[0]))(av, 3) << endl;
51
    const double * (*((*pd)[3]))(const double *, int) = &pa;
52
    const double *pdb = (*pd)[1](av, 3);
53
    cout << pdb << ":" << *pdb << endl;
54
    cout << (*(*pd)[2])(av, 3) << ":" << *(*(*pd)[2])(av, 3) << endl;
55
    return 0;
56
}
57

58
const double *f1(const double *ar, int n) {
59
    // const 保证只读，不修改地址和内容
60
    return ar; // ar = ar + 0 = &ar[0]
61
    // 返回类型是const double*
62
}
63

64
const double *f2(const double ar[], int n) {
65
    return ar + 1; // ar + 1 = &ar[1]
66
}
67

68
const double *f3(const double ar[], int n) {
69
    return ar + 2; // ar + 2 = &ar[2]
70
}

可以用auto typedef简化：typedef用法

# 内联函数#

普通函数：跳转

内敛函数：复制并替换

特点：以空间换时间、不能递归

使用需要在声明和定义加上inline

1
#include <iostream>
2
inline double square(double x) {return x*x;}
3
int main() {
4
    using namespace std;
5
    double a, b;
6
    a = square(5.0);
7
    // double x = 5.0;
8
    // a = x * x;
9
    cout << a << endl;
10
    return 0;
11
}

# 引用变量#

创建别名，内存指向同一个地方

1
int rats;
2
int & rodents = rats;// 必须初始化赋值，只能绑定一个内存空间

与指针区别：

1
int rats =101;
2
int & rodents = rats；
3
int * prats = &rats;

无法先声明再赋值

1
rodent = rat;//不允许

其与const指针更类似

# 函数传递#

**按值传递：**创建副本传递

1
int main() {
2
    int times = 20;
3
    sneezy(times);
4
    return 0;
5
}
6
void sneezy(int x) {// 创建x变量。传递20给x
7
    ……
8
}

按引用传递：

1
int main() {
2
    int times = 20;
3
    sneezy(times);
4
    return 0;
5
}
6
void sneezy(int &x){// x是times别名
7
    ……
8
}

按指针传递：

1
int main() {
2
    int times = 20;
3
    sneezy(&times);
4
    return 0;
5
}
6
void sneezy(int *x){// x是time指针
7
    ……
8
}

比较：

1
#include <iostream>
2
void swapr(int &a, int &b);
3
void swapp(int* p, int* q);
4
void swapv(int a, int b);
5
int main() {
6
    using namespace std;
7
    int wallet1 = 100;
8
    int wallet2 = 350;
9
    cout <<"wallet1 = "<<wallet1<<" wallet2 = "<<wallet2<<endl;
10
    cout << "using references to swap contents:"<<endl;
11
    swapr(wallet1,wallet2);
12
    cout << "wallet1 = "<<wallet1<<" wallet2 = "<<wallet2<<endl;
13

14
    cout << "using pointers to swap contents:"<<endl;
15
    swapp(&wallet1,&wallet2);
16
    cout << "wallet1 = "<<wallet1<<" wallet2 = "<<wallet2<<endl;
17

18
    cout << "Trying to use passing by value:"<<endl;
19
    swapv(wallet1,wallet2);
20
    cout<<"wallet1 = "<<wallet1<<" wallet2 = "<<wallet2;
21
    return 0;
22
}
23

24
void swapr(int &a, int &b) {
25
    int temp = a;
26
    a = b;
27
    b = temp;
28
}
29
void swapp(int* p, int* q) {
30
    int temp = *p;
31
    *p = *q;
32
    *q = temp;
33
}
34
void swapv(int a, int b) {
35
    int temp = a;
36
    a = b;
37
    b = temp;
38
}

指针在操作过程中需要*，引用不用

# 区分左值和右值#

&可以取地址就是左值，不能就是右值

注意：字符串可以取地址，是左值

引用必须是左值

# 临时变量#

引用使用右值的时候，可以加const作为临时变量

1
cout << recube(10);
2
double recube(const double& ra){
3
  return ra*ra*ra;
4
}

实参类型不正确，使用const自动转换

1
int x = 2;
2
cout << recube(x);
3
double recube(const double& ra){
4
  return ra*ra*ra;
5
}

字符串取地址要用const修饰

1
const string& b = "abc";

在引用推荐尽可能使用const

1
double && rref = 6.0//C++11新特性：引用右值

避免返回临时变量的引用

1
// 错误示例
2
const free_throws & clone2(free_throws & ft){
3
  free_throws newguy;//创建临时变量的引用
4
  newguy = ft;
5
  return newguy;//返回临时变量引用，错误
6
}

函数调用结束会销毁临时变量，解决方法：返回给传入的引用

# 结构和引用#

1
#include <iomanip>
2
#include <iostream>
3
#include <numeric>
4
#include <string>
5
struct free_throws{
6
    std::string name;
7
    int made;
8
    int attempts;
9
    float percent;
10
};
11
void set_pc(free_throws& ft);
12
void display(const free_throws& ft);
13
free_throws & accumulate(free_throws & target,const free_throws & source);
14
int main(){
15
    using namespace std;
16
    free_throws one = { "Ifelsa Branch", 13, 14 };
17
    free_throws two = { "Andor Knott", 10,16 };
18
    free_throws three ={ "Minnie Max",7,9 };
19
    free_throws four = { "Whily Looper", 5,9 };
20
    free_throws five = { "Long Long", 6,14 };
21
    free_throws team = {"Throwgoods", 0,0 };
22
    free_throws dup;
23
    set_pc(one);
24
    display(one);
25
    accumulate(team,one);
26
    display(team);
27
    display(accumulate(team,team));
28
    accumulate(accumulate(team,three),four);
29
    display(accumulate(team,five));
30
    dup = accumulate(team,five);
31
    display(team);
32
    display(dup);
33
    set_pc(four);
34
    accumulate(dup,five)=four;//返回的引用被four结构体赋值
35
    display(dup);
36

37
    return 0;
38
}
39

40
void set_pc(free_throws& ft) {//one别名
41
    if (ft.attempts != 0) {
42
        ft.percent = float(ft.made)/float(ft.attempts);
43
    }else {
44
            ft.percent = 0;
45
        }
46
    }
47
    void display(const free_throws& ft) {
48
        using namespace std;
49
        cout << "name: " << ft.name << endl;
50
        cout << "made: " << ft.made << endl;
51
        cout << "attempts: " << ft.attempts << endl;
52
        cout << "percent: " << ft.percent << endl;
53
    }
54
free_throws & accumulate(free_throws & target,const free_throws & source) {//返回值是引用
55
    target.attempts += source.attempts;
56
    target.made += source.made;
57
    set_pc(target);
58
    return target;
59
}

# 默认参数#

在函数原型中说明默认参数

1
char * left（const char * str,int n =1）;//,n默认为1

此时n可以不传

# 函数重载#

1
void print(const char *str ,int width);
2
void print(double d,int width);
3
void print(long l,int width);

根据参数列表选择

# 函数模板#

函数模板是泛型

1
void swapr(int &a, int &b) {
2
    int temp = a;
3
    a = b;
4
    b = temp;
5
}
6
void swapp(int* p, int* q) {
7
    int temp = *p;
8
    *p = *q;
9
    *q = temp;
10
}

函数遇到这种参数类型外其他一样，可以使用函数模板简化

1
template <typename AnyType>//声明模板
2
// typename（以及class）是参数类型 AnyType是类型名（可自定义）
3
void Swap(AnyType &a,AnyType &b) {
4
    AnyType temp;
5
    temp=a;
6
    a=b;
7
    b=temp;
8
}

通常会放在头文件里

# 具体化#

1
// 模板函数
2
template <typename T>
3
void Swap(T &,T &);
4
// 显示具体化的模板函数
5
template <> void Swap<job>(job &,job &);
6
template <> void Swap<>(job &,job &);//前job可省略
7
{
8
  ……
9
}

直接在特定某处写了个模板（类似直接定义模板，不走头文件的模板）

1
Swap(a,b);//隐式实例化
2
Swap<int>(a,b);//显式示例化，直接在前面的模板套上int

# decltype关键字#

1
template<class T1,class T2>
2
void ft(T1 x,T2 y){
3
  //x+y:当T1+T2的时候，不知道结果的类型，使用decltype自动处理
4
  decltype(x+y) xpy = x+y;
5
}

# 名称空间和内存模型#

# 单独编译#

把一个程序文件拆分成多个文件：

头文件：包含结构（struct）、类（class）、模板的声明；函数原型、#define、const、内联函数
源文件：包含与结构有关的函数代码
源代码：包含调用与结构相关函数的代码

#是预编译

1
#include<iostream>//系统提供，尖括号
2
#include"abc.h"//自己编写，引号

避免重复定义方法，如果定义只看第一次：

1
#ifndef CORRDIN_H_
2
#define CORRDIN_H_
3
  ……
4
#endif

嗨！别来无恙啊！

C++要领#

#扩展名#

# 注释#

# 函数#

# 简单变量#

# 整型#

# 字符和字符串#

# 布尔类型#

# const 限定符#

# 特殊初始化语法#

# 类型转换#

# 类型转换的规则#

# 自动判断类型 auto声明#

# 数组#

# 三要素#

# 声明#

# 初始化规则#

# 计算数组的元素个数#

# 字符串#

# 读取字符串#

# string 类#

# string 类IO#

# 结构体#

# 结构数组#

# 共用体#

# 枚举#

# 设置枚举量值#

# 取值范围#

# 指针#

# new 分配内存，delete 释放内存#

# new 创建动态数组#

# 创建动态结构#

# 模板类 vector#

# 模板类 array#

# 对比#

# 循环#

# 前后缀递增递减#

# 语句块#

# 逗号运算符#

# C 风格字符串比较#

# String 比较#

# while 编写延时#

# 类型别名#

# 基于范围的for循环#

# 文件尾条件（EOF）#

# 二维数组和循环嵌套#

# 逻辑运算符#

# cctype库函数#

一、处理类#

二、判断类#

# ?:运算符号#

# switch#

# break 和 continue#

# 输入输出到文件#

# 输出到文件#

# 读取文件#

# 函数#

# 函数和数组#

# 只读指针#

# 返回字符串#

# string对象#

# array对象#

# 递归#

# 函数指针#

# 内联函数#

# 引用变量#

# 函数传递#

# 区分左值和右值#

# 临时变量#

# 结构和引用#

# 默认参数#

# 函数重载#

# 函数模板#

# 具体化#

# decltype关键字#

# 名称空间和内存模型#

# 单独编译#