分类： C++

• 函数和数组
• 函数和结构
• 函数和指针
• 函数和string
• 函数递归

函数定义：

typename functionnname(parameterlist){
     statements;
     return value;
}

函数原型：如果函数定义在函数调用之后，必须在函数调用前进行函数原型声明，函数原型描述了函数到编译器的接口，将函数返回值类型、参数类型和数量告诉编译器。 函数原型是一条语句，就是函数定义中的函数头，此外，在原型的参数中不要求提供变量名，有类型列表就足够了。

函数参数和按值传递：

函数和数组：

1、输入为数组：

定义：
int sum_array (int array[],int n)
实际情况是array是一个指针，在函数内部，array可以看成是数组
调用：
sum_array(cooke,4) 其中cooke是数组名

2、使用指针处理数组:

数组名==指针


定义：
int sum_array (int* array,int n)
调用：
sum_array(cooke,4) 其中cooke是数组名

3、使用 输入为数组区间的函数：

 int sum_array (const int* start,const int* end ) 
调用：

sum_array(cooke,cooke+3) 其中cooke是数组名

指针和const：

将const用于指针有很微妙的地方，第一种方法是让指针指向一个常量对象，这样可以防止该指针来修改所指向的值，第二种方法是将指针本身声明为常量，防止改变指针指向的位置。

但pt的声明并不意味着它指向的值实际上就是一个常量，而只意味着队医pt来说，是一个常量，因此可以通过修改age来 改变age值。

注意：c++禁止将const地址付给非const的指针，除非使用强制准换。

函数和二维数组：

定义函数： 注意这个[4]中的数字必不可少
int sum_array (int array[][4],int n)
调用:

sum_array (cooke,4)

or
定义：array是一个由4个指向int的指针组成的数组
int sum_array (int (*array)[4],int n)

函数和c风格字符串

表示字符串方法有三种：

char数组 、用括号引起的字符串常量、被设置为字符串的地址的char指针。

字符串作为参数来传递，实际传递的是字符串的第一个字符的地址，因此，需要在函数中将表示字符串的形参声明为char * 类型

int 函数名(const char * str,char ch)

函数返回c风格字符串的函数

在函数内部 声明一个字符串指针 ： char * x = char [n+1],然后return x

函数和结构：

定义结构：

struct tracal{
    int x；
    char y；
}
声明函数原型：
tracal sum(tracal x)
也可以传递结构的地址：
tracal sum(tracal *x)

函数和string 对象 array对象

函数递归：

函数指针：

函数也有地址，可以通过指针获取到函数的地址，也可以通过函数指针调用函数

1. 获取函数的地址：获取 函数地址很简单 ，只要 使用函数名（不加参数即可），例如think()是一个函数名，那么函数地址就是think。

如果要将函数作为参数进行传递，必须是传递函数名；

2. 声明函数指针：

对于函数：double pam(int)
声明一个函数指针：
double (*pf) (int)
和函数声明类似，不过是将函数名改为指针（加括号），

(*pf) (int)意味着是一个 指向函数的指针

3. 使用函数指针调用函数

double (*pf) (int) 定义之后

令： pf = pam（函数名）

调用：x=(*pf)(5)

typeof 别名

• if语句
• 逻辑运算符 && ！ ||
• cctype字符函数库
• 条件运算符:?：
• switch语句
• continue和break
• 读取数字的循环
• 基本文件输入输出

1、 if语句

if (test_condition){ body } 如果test_condition为true，那么就执行 body语句。

2、 if else 语句

if（test_condition）
    {body}
else
    {body}

3、 if else if else 语句

if（test_condition）
    {body}
else if
    {body}

else
    {body}

易错点：赋值运算符=和比较运算符==，在test_condition中使用==表达等于

逻辑表达式

1、逻辑或 ||

2、逻辑与 &&

A&&B 只有A和B都为true时，表达式才为true\

可以用来表示范围 A<20 && A> 30

3、逻辑非 ！

！A

注意： 逻辑运算符 &&和||优先级都低于关系运算符，！运算符则大于所有关系运算符和算数运算符。

此外可以使用 and or not表示

字符函数库 cctype #include <cctype>

该头文件声明了一组用于对单个字符进行分类和转换的函数。

条件运算符 ?:

表达式1?表达式2：表达式3

a>1?b=2:b=4 如果a>1,那么令b=2，否则b=4

switch语句 case中的value必须是int整数

switch(interger-expression){
    case value1: 
             body;
             break;
    case value2: 
             body;
             break;
    .............
    case valuen: 
             body;
             break;
default：body
}

break和continue

break用于switch语句，跳出switch；continue用于循环语句，用于跳出本次循环。

写文本文件

读取文件

1、for循环

for循环主要完成以下部分：1、设置初始值 2、判断循环是否继续进行 3、执行循环操作 4、更新用于测试的值

for(初始值;测试条件;更新测试值)//初始值可以 自定义变量   int x = 0

for循环中更新值：i++ i– 也可以选择不同步长 i = i+2 i=i+4

2、递增运算符 ++ 和 递减运算符 —

a++ ：先使用a，在a自增 ++a ：先a自加一，在使用a

for循环语句块：

字符串的比较：

string类字符串比较：

3、while循环

while(循环条件){
body
}

4、类型别名

方法一：

方法二：

5、do while 循环

基于范围的循环 （C++11 新增）

用于数组或者容器类，如vector 和 array。

for ( int x : array) { body }

如果要在循环体对 x进行修改：for (int &x : arrayname) 需要使用引用。

循环和文本输入：

1、使用原始cin输入：

补救：使用cin.get(char):会读取空格，并赋给char

文件尾条件 EOF

二维数组

初始化：

使用二维数组： maxtemps[1][2]

• 1、数组

数组声明： typename arrayname[arraysize]

或者 在声明时候赋值 int x[2]={1,2};

如果只对数组的一部分进行初始化，则编译器会把其他元素设置为0，因此：

long tio[5]={10};

如果初始化时方括号内【】为空，编译器自动计算元素个数：

short totals[ ]={1,2,3}

注意：arraysize指定元素的数目 ，必须是整型常数或者const值，具体来说，arraysize不能是变量。当然可以使用new运算符来避开这种限制。

访问数组元素：arrayname[i] i从0开始，到size-1

c++11 初始化数组时，省略等号 doouble x[2] {1,2};

可以不再大括号中包含任何内容 doouble x[2] {} ，这将会把所有元素设为0

c++的标准模板库提供了一种数组替代品 -模板类vector，c++11新增了array。

• 字符串

c++处理字符串方式有两种 一种来自c语言，另一种基于string类库的方法。

c语言风格字符串性质：以空字符结尾 ，空字符 \0，其ascii码为0.

char dog[3] ={‘b’,’e’,’\0′} //字符串

char cat[3] ={‘a’,’v’,’d’} //字符数组

char bird[11] = “mr. cheepes” //注意“”里不用显示的包括\0，但隐式的包括空字符，所以数组大小必须比实际长度大于一个以上。

使用键盘输入字符串时，将自动加上空字符

注意：字符串常量（” “）不能与字符常量（’ ‘）互换。”s”表示字符串，是由’s’和’\0’组成，而’s’表示单个字符。

字符串输入：

cin>>name; cin使用空白（空格、制表符、换行符）来确定字符串结束的位置，因此cin在读取 字符串时只能读取一个单词，然后将其放到数组name中。

为了解决上面的问题，将整个一行字符作为输入：istream中cin提供了类成员函数：getline()和get(),读取输入，直到遇到换行符后才停止。区别 getline() 将丢弃换行符，get将保留换行符在输入队列中。

cin.getline(name,size)

name:存储的数组名，size：读取的字符数，如果size=20，那么最多读取19个字符，且不hi存储最后的换行符，余下空间用于自动存储\0空字符。

cin.get( name,size )

混合输入字符串和数字

• string类

包含头文件 <string>，string类位于std命名空间中，必须使用using编译指令或者使用std::string引用它。

定义: string str1; string str2=”sssssss”;

赋值： cin>>str1;

显示：cout<<str1

通过访问数组的方法访问string ，str1[3]

string和字符数组区别：可以将 string对象声明为简单变量，而不是数组。声明时候不用指定大小。

c++11 初始化string ： string one={“dddfse”}; string two{“sdhfhs”}

string赋值、拼接和附加 string str2 =str1 string str3 =str1+str2

c中ctring头文件中的函数 strcpy(chaar1,charr2) //copy charr2 to charr1 strcat(charr1,charr2) 拼接charr2到charr1中

string的输入输出 cin cout，当读取一行时，使用的方法不同：

数组字符串： cin.getline(charr,20)

string: getline(cin,str1)

• 结构体

创建该类型变量 ： inflatable hat;

可以将结构作为参数传递给函数，也可以让函数返回一个结构，可以使用 = 将一个结构赋给同类型的结构。

可以在定义结构体同时创建结构变量，只需要将变量名放在定义 结构的括号后面。

结构数组

• 共用体 union

共用体是一种数据格式，能够存储不同的数据类型 ，但只能同时同时存储其中的一种类型。

声明 和struct类似

• 枚举 enum ，可以替代 const，还允许定义新类型

enum spectrum {red,orange,yellow,green,blue,violet,indigo,ultraviolet};

默认情况下，将整数值赋给枚举变量 ，第一个枚举值为0，以此类推。当然也可以显式指定整数来覆盖默认值。

枚举只有 赋值运算，没有算数运算。

如果使用 整数：需要强制类型转换 枚举名(整数)

设置枚举值

• 指针、数组

地址运算符 &变量 获得该变量的地址

指针：用于存储值的地址，使用*运算符，可以得到该地址处的值，*被称为间接值运算符，即 x是一个地址，*x时该地址的数值

可以在命名的同时赋值：

int *p

声明一个指针：

int *p or int* p or int*p

可以在声明的同时初始化: int * p= &x

注意：初始化的是 p，而不是*p

new运算符

delete 释放内存

int *p = new int

delete p

注意：只能用delete删除new分配的内存

使用 new来新建动态数组

指针小结

• 数组名是一个指针，指向的是数组array[0]
• 将&用于数组名时候，获得的是整个数组的内存地址，因此需要取 &array[0]作为数组指针的地址

指针和字符串

C++处理字符串有两种方式，即：指针方式和数组方式

数组方式：char a[] = “HelloWorld”;
指针方式：const char* s = “HelloWorld”; const可以忽略
接下来详细讲解一下字符串指针

首先，为什么字符串可以直接赋值给指针，即char* s = “HelloWorld”不会报错，不应该是把字符串的地址赋值给指针吗？

原因：这里的双引号做了3件事：

1.申请了空间(在常量区)，存放了字符串

2. 在字符串尾加上了’/0′
   3.返回地址
   为什么字符串指针的指针名输出字符串内容而不是地址？

字符串指针的指针名代表字符串的首地址，但输出字符串指针名时输出的却是完整字符串，如下：

char* s = "HelloWorld";
cout<<s<<endl; //s是字符串的首地址，但却输出HelloWorld
cout<<*s<<endl;  //输出H
cout<<*(s+1)<<endl;  //输出e，s+1是第二个字符的地址
    cout <<static_cast<void *>(s) << endl; //此时输出的才是字符串地址

原因是C++标准库中I/O类对<<操作符重载，在遇到字符型指针时会将其当作字符串名来处理，输出指针所指的字符串。既然这样，那么我们就别让它知道那是字符型指针，所以得用到强制类型转换，用static_cast把字符串指针转换成无类型指针

字符串指针指向的地址可以修改，但所指向的字符串内容不能修改，因为字符串常量是不能改变的

char* s = "HelloWorld";
s="abcd"; //合法
cout<<*(s+1)<<endl;
*(s+1)='d'; //不合法，这里虽然没报错，但这一句实际下一句并未执行
cout<<s<<endl; //未执行

字符串指针数组：

char *p[6]={"ABCD","EFGH","IJKL","MNOP"};
int i;
for(i=0;i<4;i++) 
    cout<<p[i]<<endl;  //输出每个字符串，实际上p[i]为第i个字符串的首地址
for(i=0;i<4;i++) 
    cout<<*p[i];  //输出每个字符串第一个字符AEIM
cout<<endl;
for(i=0;i<4;i++) 

cout<<*(p[i]+1); //输出每个字符串第二个字符BFJN

C++中使用char*定义字符串，不能改变字符串内的字符的内容，但却可以把另外一个字符串（新地址）赋值给它，即p1是一个char型指针变量，其值（指向）可以改变；此时，若指向的新地址为字符串数组的地址，则可更改字符串中的内容

使用new创建动态结构：

类型组合

模板类 vector 和 array

本文主要关于数据类型。面向对象编程的本质就是设计并扩展自己的的数据类型。

首先了解c++的内置数据类型 ：基本类型和复合类型

基本类型：整形和浮点型 复合类型：数组、指针、字符串、结构 存储数据的方法：变量

• 简单变量

变量命名规则：

如果想用多个单词组成一个名称，通常使用下划线字符将单词分开，如 my_onions，或者 从第二个单词开始将每个单词的第一个字母大写：myEyeTooth

• 整型

不含小数的数字 0，-3 ，100。不同的整型使用不同的内存来存储整数。有符号和无符号类型分别表示正负数和正数

short int long longlong 通过不同数目的位存储值：(都是有符号数)

short 至少16位 ：short x （short== short int）

int 至少与short一样长

long 至少32位，且至少与int一样长 （long == long int）

lonng long 之少64位，且至少与long一样长

sizeof 运算符，获得变量的所占字节，对于类型名 int等使用时，需要加括号： sizeof (int),如果是对于变量，可加可不加。

#include<iostream>
using  namespace std;
int main(){
    int x_collec =2;
    cout<<"x_collec is"<<sizeof(x_collec)<< endl;
}

初始化：

int year =2022 //如果知道变量初始值，建议定义时候赋初值。

c++11 初始化方法：将大括号用于单值变量，采用这种方法时候，=可以去掉

int x={3} or int x{3}

大括号中不含值默认为0 int z{}

头文件climits

climits定义了符号常量来并表示类型的限制： int n =INT_MAX;

• 无符号类型

要创建无符号类型，只需要使用unsigned 来修改变量声明。

unsigned   short  x  
unsigned   int  x
unsigned   long  x       

• char 类型 （也是整型）

char用于存储字符（字母和数字） char x =”M” ,实际上，计算机中存储的是对应的字符编码77，可以将x =x+1，char值位78，对应N，可以通过 （int）x强制转换为78

有些字符不能通过键盘直接输入，比如换行符不能用回车，因此，有了下面的转义字符：

char 占8bit，unsigned char 表示范围0-255， signed char 表示范围-128~127

c++11新增 char16_t char32_t, char16_t 无符号16位， char32_t 32位有符号数，使用前缀u表示 char16_t 类型的字符常量和字符串常量， 使用前缀U表示 char32_t 类型的字符常量和字符串常量 ： char16_t ch=u’q’;

• bool类型

布尔值 true or false，将非 0值解释为true，将0解释为false。字面值true和false都可以通过提升转换（不用显式强制转换）为 int类型，true转换为1，false转换为0。

• const限定符

常量被初始化后就不能修改了 const int year =2022

const type name =value

浮点数

能够表示 带小数部分的数字

书写浮点数：

1、标准写法 12.34 22.3 0.12 8.0

2、E表示法 3.45E6 指的是3.45与1000000相乘结果，E6指的是10的6次方，6是指数，指数可以是正数也可以是负数。E可以写成e。

• 浮点类型

三种：float 32位 double 64位 long double 128位，浮点数有精度限制。

float 只能保证6位精确位，double保证13位精确度。

cout所属的ostream类有一个类成员函数，能够精确的控制输出格式-字段宽度、小数位数、采用小数格式还是E格式等。后面会给出实现。

在程序中使用 浮点常量时候，默认会认为是double型，如果要指定类型，在常量后加后缀：

1.23f —-float型

1.23L —–long double

1.23 —-默认double 类型

c++ 算数运算符

加、减、乘、除、求模

除法：如果两个整数相除，结果会是一个整数（小数部分直接舍去），如果两个数中 有一个或两个是浮点数，则小数部分会被保留。（因为系统会将不同操作数进行自动准换成相同的类型）。

类型转换

1、初始化和赋值进行的转换

比如赋值时 double x = 3.14f 将一个float型付给double ，如果将double付给float变量，可能会导致降低精度。int x =3.14f 最终x=3（直接丢弃小数部分）

0赋值给bool，会转换为false，非0值会变为true

2、算数运算时

变量提升：在计算表达式时c++将 bool、char、unsigned char 、signed char 和short 转换为int。

3、传递参数时转换

4、强制类型转换

首先要明确一点强制转换不会修改变量本身 ，而是创建一个新的、指定类型的值。

以下两种方法都可以：

(long) x 或者 long (x)

(typename) value type (value)

c++还引入了强制类型转换运算符： static _cast<typename> (value)

C++中的auto声明

c++11新增了auto，让编译器能够根据初始值类型推断变量类型。

typedef

C 语言提供了 typedef 关键字，您可以使用它来为类型取一个新的名字。

typedef unsigned char BYTE;
在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写

本科大一的时候学习过c++，但因为后来大部分项目都是用python，所以基本上都还给老师了，但其实回过头发现，很多python开源库都是用c++写的，像opencv，因此很有必要去在回顾一下子c++的基本概念。

1. c++注释

以双斜杠开头： //这是一行注释，c++也能识别c注释，c注释包括在符号/* */之间，可以跨越多行。

#include <iostream>  
int main (){  
#c++ 例子  
    usinng namespace std;  
    cout<<"hello world"  
    cout<<endl;  
    return 0  
}  

2. 预处理器和iostream

#include <iostream>

3. 头文件和命名空间

如果使用iostream，而不是iostream.h，则应使用下面的名称空间编译指令来使iostream中的定义对程序可用： using namespace std；

命名空间作用：假如两个封装好的库，都有名为cout的函数，那么在调用cout时，编译器不知道是哪个函数，因此可以把某个库中函数定义到一个命名空间，就可以通过 std:cout (命名空间:函数名)调用，此外，这样写比较麻烦，还可以使用using，而不必使用std前缀 ： using namespace std ；使得std中所有名称可用。在大型工程中，一般使用：using std:cout; using std:cin;单独定义所需的函数

4. 输入输出

cout<<“hello” 和 cin<<a cout 还可以拼接 cout<<“s”<<“v”<<endl;

endl 是一个特殊的c++符号，表示换行，此外还可以使用c中的\n换行符 cout<<“hello \n”

5. 声明语句和变量

int carrots; 这条语句声明了需要的内存和内存单元名称.为什么需要声明变量：如果不显示的声明，那么当我们在多次使用 carrots 变量时候，如果中间有个写错了 carrot ，系统不会报错，而是认为这是一个新的变量。

变量赋值 a=3

6. 函数

type functionname(argumentlist){ statements }

函数头： type functionname(argumentlist) ，函数中可以使用using编译指令，起作用范围为函数内部。

如果using 放置在函数定义之前，文件中所有的函数都可以使用std中的元素，using放在特定函数中，则该函数能使用