[C++] 2021版C++教程，一文搞定C++入门进阶教程！

• 对象-对象具有状态的行为。对象是类的实例。
  
• 类-类可以定义为对象行为、状态的模版。
  
• 方法-从基本上讲，一个方法表示一种行为，一个类可以包含多种方法。
  
• 变量
  

• 布尔常量：布尔常量只有两个，一个是true，表示真；另一个是false，表示假。
  
• 枚举常量：枚举型数据中定义的成员也是常量，这将在后文介绍。
  
• 宏定义常量：通过#define宏定义的一些值也是常量。例如：define PI3.1415。其中PI就是常量。
  

• 有字母、数字及下划线组成，且不能以数字开头。
  
• 大写和小写字母代表不同意义。
  
• 不能与关键字同名
  
• 尽量“见名知义”，应该受一定规则的约束。
  
• 不合法的标识符：6A、ABC*、case（保留字）
  

• 整型 [signed] int
  
• 无符号整型 unsigned [int]
  
• 有符号短整型 [signed] short [int]
  
• 无符号短整型 unsigned short [int]
  
• 有符号长整型 [signed] long [int]
  
• 无符号长整型 unsigned long [int]
  

• int x=5;：表示定义x为有符号的基本整型变量，赋初值为5
  
• int x，y，z=6;：表示定义x、y、z为有符号的基本整型变量，z赋初值为6
  
• int x=3，y=3，z=3;：表示定义x、y、z为有符号的基本整型变量，且赋予的初值均为3
  

• 一个字符类型，即可以字符形式输出，也可以整数类型输出：
  

• 允许对字符数据进行算术运算，此时就是对它们的ASCII码值进行算术运算： 
  

//定义结构体同时声明结构体变量名
struct 结构体类型名
{
成员类型1 成员名1;
成员类型2 成员名2;
... ...
成员类型n 成员名n;
}变量名1,变量名2,...变量名n;
//先定义结构体
[struct] 结构体类型名 变量名;
//直接定义
struct 
{
成员类型1 成员名1;
成员类型2 成员名2;
... ...
成员类型n 成员名n;
}变量名1,变量名2,...变量名n;
struct  person
{
int year;
int age;
string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };
struct  person
{
int year;
int age;
string name;
};
struct person p1 = { 2019,24,"heiren" }, p1 = { 2020,24,"heiren" };
struct 
{
int year;
int age;
string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };

• 具有相同类型的结构体变量可以进行赋值运算，但是不能输入输出
  
• 对结构体变量的成员引用：结构体变量名.成员名
  
• 指向结构体的指针变量引用格式：指针变量名->成员名;
  结构体数组的定义，初始化和使用与结构体变量、基本类型数组相似
  

struct person
{
int year;
int age;
string name;
}p[2] ={ {2019,24,"heiren"}, { 2020,24,"heiren" }};//可以不指定数组元素个数
p[1].age;

union 共同体类型名
{
  成员类型1 成员名1;
成员类型2 成员名2;
... ...
成员类型n 成员名n;
};

• 不可以自己定义新的运算符，只能对已有的C++运算符重载。
  
• 不能改变运算符运算对象的个数。
  
• 不能改变运算符的优先级和结合性
  
• 应与标准类型运算功能相似，避免影响可读性。
  

函数类型 operator运算符(参数列表)
{
函数体
}
//举个栗子：定义一个向量类，通过运算符重载，可以用+进行运算。
class Vector3
{
public:
Vector3();
Vector3(double x,double y,double z);
public:
Vector3 operator+(const Vector3 &A)const;
void display()const;
private:
double m_x;
double m_y;
double m_z;
};
Vector3::Vector3() :m_x(0.0), m_y(0.0), m_z(0.0) {}
Vector3::Vector3(double x, double y,double z) : m_x(x), m_y(y), m_z(z) {}
//运算符重载
Vector3 Vector3::operator+(const Vector3 &A) const
{
Vector3 B;
B.m_x = this->m_x + A.m_x;
B.m_y = this->m_y + A.m_y;
B.m_z = this->m_z + A.m_z;
return B;
}
void  Vector3::display()const
{
cout<<"(" << m_x << "," << m_y << "," << m_z << ")" << endl;
}

• 自增自减
  
• 赋值运算符
  
• 输入\输出运算符重载
  

• init首先被执，且只会执行一次，也可以不写任何语句。
  
• 然后会判断conditon,true执行循环主体，false跳过循环
  
• 执行完循环主体，执行increment,跳到2
  

• for each
  STL中的for增强循环。
  

• if
  

if(expr)
{
statement;//如果expr为true将执行的语句块 
}
if(expr)
{
   statement1;// 如果expr为true将执行的语句块
}
else
{
   statement2;// 如果expr为false将执行的语句
}
if(expr1)
{
   statement1;// 如果expr1为true将执行的语句块
}
elseif(expr2)
{
   statement2;// 如果expr2为true将执行的语句块
}
...
else
{
statementElse;// 当上面的表达式都为false执行的语句块
}

• switch
  

char c = 'A';
switch (c)
{
case 'A':
case 'B':
case 'C':
cout << "及格了" << endl;
break;
default:
cout << "不及格" << endl;
}

//如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值
Exp1 ? Exp2 : Exp3;

• 宏定义：#define 标识符 字符串
  
• 文件包含：#include<filename> 或者#include“filename”
  
• 条件编译
  

• 初始化数组时，可以只给部分数组元素赋值
  
• 对全部元素数组赋值时，可以不指定数组长度，编译系统会根据初值个数确定数组的长度。
  
• static型数组元素不赋初值，系统会自动默认为0。
  

• 数据类型是指针变量所指向的变量的数据类型，*表示其后的变量为指针变量
  

• &是取地址运算符，&变量名表示变量的地址。
  
• 变量的数据类型必须于指针变量的数据类型一致。
  
• 为了安全起见，有时会把指针初始化为空指针（NULL或0）
  

• & 取地址符 * 指针运算符（间接运算符），其后是指针变量，表示该指针变量所指向的变量。
  
• & *的优先级是相同的，结合方式都是自左向右。比如 &*p等价于&(*p)。
  

• new-为变量分配内存空间；
  
• 可以通过判断new返回的指针的值，判断空间是否分配成功。
  
• delete-释放空间
  

• 字符串数组名：char ch[] = "heiren";char *p = ch;
  
• 字符串：char *p = "heiren";
  
• 指针赋值运算：char * p;p = "Heiren";
  指针与函数，指针可以作为函数的参数，也可以作为函数的返回值。
  

• 函数类型-函数的返回值类型；函数名-必须符合C++标识符命名规则，后面必须跟一对括号；函数体-实现函数功能的主题部分；参数列表-函数名后面的括号内，用于向函数传递数值或带回数值。
  
• 函数声明中，参数名可以省略，参数类型和函数的类型不能省略。
  
• 函数声明可以放在主调函数内部，放在调用语句之前；也可以放在主调函数外，如果位于所有定义函数之前，后面函数定义顺序任意，各个主调函数调用也不必再做声明
  
• 当函数定义在前，函数调用灾后，可以不用函数声明。
  

• 形参：函数定义后面括号里的参数，函数调用前不占内存。
  
• 实参：函数调用括号里的参数，可以是常量，变量或表达式等。
  

• 函数可以单独作为一个语句使用。有返回值的函数，可将函数调用作为语句的一部分，利用返回值参与运算。
  函数调用形式：参数传递–>函数体执行–>返回主调函数
  

• 一个函数直接或间接递归调用该函数本身，称为函数的递归调用
  
• 递归和回归：原问题=>子问题 子问题的解=>原问题的解
  

//直接递归调用：求1+...n的值
int total(int sum)
{
if (sum == 1)
{
return 1;
}
return sum + total(sum - 1);
}
int main()
{
cout << "total = " << total(10) << endl;//total = 55
system("pause");
return 0;
}
//间接递归调用
int f2();
int f1()
{
...
  f2()
}
int f2()
{
f1();
}

#include <iostream>
#include <algorithm>
#include <string>
string str;//生成空字符串
string s(str);//生成字符串为str的复制品
string s(str, strbegin,strlen);//将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值
string s(cstr, char_len);//以C_string类型cstr的前char_len个字符串作为字符串s的初值
string s(num ,c);//生成num个c字符的字符串
string s(str, stridx);//将字符串str中从下标stridx开始到字符串结束的位置作为字符串初值
size()和length();//返回string对象的字符个数
max_size();//返回string对象最多包含的字符数，超出会抛出length_error异常
capacity();//重新分配内存之前，string对象能包含的最大字符数
>,>=,<,<=,==,!=//支持string与C-string的比较(如 str<”hello”)。  使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较，string (“aaaa”) <string(aaaaa)。  
compare();//支持多参数处理，支持用索引值和长度定位子串来进行比较。返回一个整数来表示比较结果，返回值意义如下：0：相等 1：大于 -1：
  
push_back() 
insert( size_type index, size_type count, CharT ch );//在index位置插入count个字符ch
insert( size_type index, const CharT* s );//index位置插入一个常量字符串
insert( size_type index, const CharT* s, size_type n);//index位置插入常量字符串
insert( size_type index, const basic_string& str );//index位置插入常量string中的n个字符
insert( size_type index, const basic_string& str, size_type index_str, size_type n);//index位置插入常量str的从index_str开始的n个字符
insert( size_type index, const basic_string& str,size_type index_str, size_type count = npos);//index位置插入常量str从index_str开始的count个字符，count可以表示的最大值为npos.这个函数不构成重载 npos表示一个常数，表示size_t的最大值，string的find函数如果未找到指定字符，返回的就是一个npos
iterator insert( iterator pos, CharT ch );
iterator insert( const_iterator pos, CharT ch );
void insert( iterator pos, size_type n, CharT ch );//迭代器指向的pos位置插入n个字符ch
iterator insert( const_iterator pos, size_type count, CharT ch );//迭代器指向的pos位置插入count个字符ch
void insert( iterator pos, InputIt first, InputIt last );
iterator insert( const_iterator pos, InputIt first, InputIt last );
append() 和 + 操作符
//访问string每个字符串
string s1("yuanrui"); // 调用一次构造函数
// 方法一： 下标法
for( int i = 0; i < s1.size() ; i++ )
   cout<<s1[i];
// 方法二：正向迭代器
for( string::iterator iter = s1.begin();; iter < s1.end() ; iter++)
   cout<<*iter;
 // 方法三：反向迭代器
for(string::reverse_iterator riter = s1.rbegin(); ; riter < s1.rend() ; riter++)
   cout<<*riter;
 iterator erase(iterator p);//删除字符串中p所指的字符
iterator erase(iterator first, iterator last);//删除字符串中迭代器区间[first,last)上所有字符
string& erase(size_t pos = 0, size_t len = npos);//删除字符串中从索引位置pos开始的len个字符
void clear();//删除字符串中所有字符
string& replace(size_t pos, size_t n, const char *s);//将当前字符串从pos索引开始的n个字符，替换成字符串s
string& replace(size_t pos, size_t n, size_t n1, char c); //将当前字符串从pos索引开始的n个字符，替换成n1个字符c
string& replace(iterator i1, iterator i2, const char* s);//将当前字符串[i1,i2)区间中的字符串替换为字符串s
//tolower()和toupper()函数 或者 STL中的transform算法
string s = "ABCDEFG";
for( int i = 0; i < s.size(); i++ )
   s[i] = tolower(s[i]);
transform(s.begin(),s.end(),s.begin(),::tolower);
size_t find (constchar* s, size_t pos = 0) const;//在当前字符串的pos索引位置开始，查找子串s，返回找到的位置索引，-1表示查找不到子串
size_t find (charc, size_t pos = 0) const;//在当前字符串的pos索引位置开始，查找字符c，返回找到的位置索引，-1表示查找不到字符
size_t rfind (constchar* s, size_t pos = npos) const;//在当前字符串的pos索引位置开始，反向查找子串s，返回找到的位置索引，-1表示查找不到子串
size_t rfind (charc, size_t pos = npos) const;//在当前字符串的pos索引位置开始，反向查找字符c，返回找到的位置索引，-1表示查找不到字符
size_tfind_first_of (const char* s, size_t pos = 0) const;//在当前字符串的pos索引位置开始，查找子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_tfind_first_not_of (const char* s, size_t pos = 0) const;//在当前字符串的pos索引位置开始，查找第一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_t find_last_of(const char* s, size_t pos = npos) const;//在当前字符串的pos索引位置开始，查找最后一个位于子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_tfind_last_not_of (const char* s, size_t pos = npos) const;//在当前字符串的pos索引位置开始，查找最后一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到子串
sort(s.begin(),s.end());
substr(pos,n);//返回字符串从下标pos开始n个字符
strtok()
char str[] = "I,am,a,student; hello world!";
const char *split = ",; !";
char *p2 = strtok(str,split);
while( p2 != NULL )
{
  cout<<p2<<endl;
  p2 = strtok(NULL,split);
}

//类外
返回类型 类名:成员函数名(参数列表)
{
函数体;
}
//内联函数：类外
inline 返回类型 类名:成员函数名(参数列表)
{
函数体;
}

//1.声明类同时定义对象
class 类名
{
类体;
}对象名列表;
//2.先声明类，再定义对象
类名 对象名(参数列表);//参数列表为空时，()可以不写
//3. 不出现类名，直接定义对象
class 
{
类体;
}对象名列表;
//4.在堆上创建对象
Person p(123, "yar");//在栈上创建对象
Person *pp = new Person(234,"yar");//在堆上创建对象

类名 对象名(参数列表);//参数列表为空时，()可以不写

class Person
{
public:
Person(int = 0,string = "张三");
void show();
private:
int age;
string name;
};
Person::Person(int a, string s)
{
cout<<a<<" "<<s<<endl;
age = a;
name = s;
}
void Person::show()
{
cout << "age="<<age << endl;
cout << "name=" <<name << endl;
}
int main()
{
   Person p; //0 张三
Person p2(12);//12 张三
Person p3(123, "yar");//123 yar
return 0;
}

类名::类名(类名&对象名)
{
函数体;
}
class Person
{
public:
Person(Person &p);//声明拷贝构造函数
Person(int = 0,string = "张三");
void show();
private:
int age;
string name;
};
Person::Person(Person &p)//定义拷贝构造函数
{
cout << "拷贝构造函数" << endl;
age = 0;
name = "ABC";
}
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
int main()
{
Person p(123, "yar");
Person p2(p);
p2.show();
return 0;
}
//输出
123 yar
拷贝构造函数
age=0
name=ABC

​ 6、6、对象指针

类名 *对象指针名;
对象指针 = &对象名;
//访问对象成员
对象指针->数据成员名
对象指针->成员函数名(参数列表)
Person p(123, "yar");
Person* pp = &p;
Person* pp2 = new Person(234,"yar")
pp->show();

数据成员类型 *指针变量名 = &对象名.数据成员名;
函数类型 (类名::*指针变量名)(参数列表);
指针变量名=&类名::成员函数名;
(对象名.*指针变量名)(参数列表);
Person p(123, "yar");
void(Person::*pfun)();
pfun = &Person::show;
(p.*pfun)();

• static 成员变量属于类，不属于某个具体的对象
  
• 静态成员函数只能访问类中静态数据成员
  静态数据成员
  

//1.将非成员函数声明为友元函数
class Person
{
public:
Person(int = 0,string = "张三");
friend void show(Person *pper);//将show声明为友元函数
private:
int age;
string name;
};
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
void show(Person *pper)
{
cout << "age="<< pper->age << endl;
cout << "name=" << pper->name << endl;
}
int main()
{;
Person *pp = new Person(234,"yar");
show(pp);
system("pause");
return 0;
}
//2.将其他类的成员函数声明为友元函数
//person中的成员函数可以访问MobilePhone中的私有成员变量
class MobilePhone;//提前声明
//声明Person类
class Person
{
public:
Person(int = 0,string = "张三");
void show(MobilePhone *mp);
private:
int age;
string name;
};
//声明MobilePhone类
class MobilePhone
{
public:
MobilePhone();
friend void Person::show(MobilePhone *mp);
private:
int year;
int memory;
string name;
};
MobilePhone::MobilePhone()
{
year = 1;
memory = 4;
name = "iphone 6s";
}
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
void Person::show(MobilePhone *mp)
{
cout << mp->year << "年  " << mp->memory << "G " << mp->name << endl;
}
int main()
{
Person *pp = new Person(234,"yar");
MobilePhone *mp = new MobilePhone;
pp->show(mp);
system("pause");
return 0;
}

• 类之间的友元关系不能传递
  
• 类之间的友元关系是单向的
  
• 友元关系不能被继承
  

class Base
{
public:
void show();
protected:
int aa;
double dd;
};
void Base::show(){
}
class Person:public Base
{
public:
using Base::aa;//将基类的protected成员变成public
using Base::dd;//将基类的protected成员变成public
private:
using Base::show;//将基类的public成员变成private
string name;
};
int main()
{
Person *p = new Person();
p->aa = 12;
p->dd = 12.3;
p->show();//出错
delete p;
return 0;
}

• 先执行基类的构造函数，随后执行派生类的构造函数
  
• 先执行派生类的析构函数，再执行基类的析构函数。
  
• 派生类的构造函数：派生类名(总参数列表)：基类名(基类参数列表),子对象名1(参数列表){构造函数体;}
  

class Base
{
public:
Base(int, double);
~Base();
private:
int aa;
double dd;
};
Base::Base(int a, double d) :aa(a), dd(d)
{
cout << "Base Class 构造函数!!!" << endl;
}
Base::~Base()
{
cout << "Base Class 析构函数!!!" << endl;
}
class Person:public Base
{
public:
Person(int,double,string);
~Person();
private:
string name;
};
Person::Person(int a,double d,string str):Base(a,d),name(str)
{
cout << "Person Class 构造函数!!!" << endl;
}
Person::~Person()
{
cout << "Person Class 析构函数!!!" << endl;
}
int main()
{
cout << "创建Person对象..." << endl;
Person *p = new Person(1,2,"yar");
cout << "删除Person对象...." << endl;
delete p;
system("pause");
return 0;
}

多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。

• 1.类名::同名成员名;
  
• 2.派生类定义同名成员，访问的就是派生类同名成员。
  

class  A//虚基类
{
protected:
int a;
};
class B: virtual public A
{
protected:
int b;
};
class C:virtual public A
{
protected:
int c;
};
class D:public B,public C
{
protected:
int d;
void show()
{
b = 123;
c = 23;
a = 1;
}
};

• 静态多态性-在程序编译时系统就决定调用哪个函数，比如函数重载和静态多态性
  
• 动态多态性-在程序运行过程中动态确定调用那个函数，通过虚函数实现的。
  

• 将基类中的函数声明为虚函数，派生类中的同名函数自动为虚函数。
  
• 声明形式：virtual 函数类型 函数名 (参数列表);
  
• 构造函数不能声明为虚函数，析构函数可以声明为虚函数。
  

class  A
{
public:
virtual void show()
{
cout << "A show" << endl;
}
};
class B:  public A
{
public:
void show()
{
cout << "B show" << endl;
}
};
int main()
{
B b;
b.show();//B show
A *pA = &b;
pA->show();//B show 如果show方法前没用virtual声明为虚函数，这里会输出A show
system("pause");
return 0;
}

​十十一、IO流

• istream 是用于输入的流类，cin 就是该类的对象。
  
• ostream 是用于输出的流类，cout 就是该类的对象。
  
• ifstream 是用于从文件读取数据的类。
  
• ofstream 是用于向文件写入数据的类。
  
• iostream 是既能用于输入，又能用于输出的类。
  
• fstream 是既能从文件读取数据，又能向文件写入数据的类。
  
• istrstream 输入字符串类
  
• ostrstream 输出字符串类
  
• strstream 输入输出字符串流类
  

int  x;
double y;
cin>>x>>y;
//输入 22 66.0  两个数之间可以用空格、制表符和回车分隔数据
char str[10];
cin>>str;//hei ren  字符串中只有hei\0

• get函数：cin.get()，cin.get(ch)（成功返回非0值，否则返回0），cin.get(字符数组(或字符指针)，字符个数n,终止字符)
  

•  getline函数：cin.getline(字符数组(或字符指针),字符个数n,终止标志字符)读取字符知道终止字符或者读取n-1个字符，赋值给指定字符数组（或字符指针）
  

• cin.peek() 不会跳过输入流中的空格、回车符。在输入流已经结束的情况下，cin.peek() 返回 EOF。
  
• ignore(int n =1, int delim = EOF)
  

•  putback(char c)，可以将一个字符插入输入流的最前面。
  

• 插入endl-输出所有数据，插入换行符，清空缓冲区
  
• \n-输出换行，不清空缓冲区
  
• cout.put(参数) 输出单个字符（可以时字符也可以是ASII码）
  

• *不是算子的一部分，星号表示在没有使用任何算子的情况下，就等效于使用了该算子，例如，在默认情况下，整数是用十进制形式输出的，等效于使用了 dec 算子
  

​4、文件指针移动操作

• ifstream 类和 fstream 类有 seekg 成员函数，可以设置文件读指针的位置；
  
• ofstream 类和 fstream 类有 seekp 成员函数，可以设置文件写指针的位置。
  
• ifstream 类和 fstream 类还有 tellg 成员函数，能够返回文件读指针的位置；
  
• ofstream 类和 fstream 类还有 tellp 成员函数，能够返回文件写指针的位置。
  

ostream & seekp (int offset, int mode);
istream & seekg (int offset, int mode);
//mode有三种：ios::beg-开头往后offset(>=0)字节 ios::cur-当前往前(<=0)/后(>=0)offset字节 ios::end-末尾往前(<=0)offect字节
int tellg();
int tellp();
//seekg 函数将文件读指针定位到文件尾部，再用 tellg 函数获取文件读指针的位置，此位置即为文件长度

• 泛型程序设计在实现时不指定具体要操作的数据的类型的程序设计方法的一种算法，指的是算法只要实现一遍，就能适用于多种数据类型，优势在于代码复用，减少重复代码的编写。
  
• 模板是泛型的基础，是创建泛型类或函数的蓝图或公式
  

template<class T>或template<typename T>
函数类型 函数名(参数列表)
{
函数体;
}
template<class T1,class T2,...>//class可以换成typename
函数类型 函数名(参数列表)
{
函数体;
}
//举个栗子
template<class T> T max(T a, T b)
{
return a > b ? a : b;
}
int main()
{
cout <<"max value is "<< max(12,34) << endl;//34
cout << "max value is " << max(12.4, 13.6) << endl;//13.6
cout << "max value is " << max(12.4, 13) << endl;//error 没有与参数列表匹配的 函数模板 "max" 实例参数类型为:(double, int)
return 0;
}

class MyClass
{
public:
typedef int LengthType;
LengthType getLength() const
{
return this->length;
}
void setLength(LengthType length)
{
this->length = length;
}
private:
LengthType length;
};
template<class T>
void MyMethod(T myclass)
{
//告诉 c++ 编译器，typename 后面的字符串为一个类型名称，而不是成员函数或者成员变量
typedef typename T::LengthType LengthType; //
LengthType length = myclass.getLength();
cout << "length = " <<length<< endl;
}
int main()
{
MyClass my;
my.setLength(666);
MyMethod(my);//length = 666
return 0;
}

• 正向迭代器：容器类名::iterator 迭代器名;
  
• 常量正向迭代器：容器类名::const_iterator 迭代器名;
  
• 反向迭代器：容器类名::reverse_iterator 迭代器名;
  
• 常量反向迭代器：容器类名::const_reverse_iterator 迭代器名
  

• copy：将一个容器的内容复制到另一个容器。
  
• remove：在容器中删除一个元素。
  
• random_shuffle：随机打乱容器中的元素。
  
• fill：用某个值填充容器。
  

• find：在容器中查找元素。
  
• count_if：统计容器中符合某种条件的元素的个数。
  

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main()  {
   vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4); //1,2,3,4
vector<int>::iterator p;
p = find(v.begin(), v.end(), 3); //在v中查找3 若找不到,find返回 v.end()
if (p != v.end())
cout << "1) " << *p << endl; //找到了
p = find(v.begin(), v.end(), 9);
if (p == v.end())
cout << "not found " << endl; //没找到
 
p = find(v.begin() + 1, v.end() - 1, 4); //在2,3 这两个元素中查找4
cout << "2) " << *p << endl; //没找到，指向下一个元素4
 
int arr[10] = { 10,20,30,40 };
int * pp = find(arr, arr + 4, 20);
if (pp == arr + 4)
cout << "not found" << endl;
else
cout << "3) " << *pp << endl;
return 0;
 
}