C++易错小结

C++ 11 vector 遍历方法小结

方法零，对C念念不舍的童鞋们习惯的写法：

void ShowVec(const vector<int>& valList)
{
    int count = valList.size();
    for (int i = 0; i < count;i++)
    {
        cout << valList[i] << endl;
    }
}

方法一，大家喜闻乐见的for循环迭代器输出，（注意，此处使用了C++11中新增的标准库容器的cbegin函数）

void ShowVec(const vector<int>& valList)
{
    for (vector<int>::const_iterator iter = valList.cbegin(); iter != valList.cend(); iter++)
    {
        cout << (*iter) << endl;
    }
}

void ShowVec(const vector<int>& valList)
{
    for (auto iter = valList.cbegin(); iter != valList.cend(); iter++)
    {
        cout << (*iter) << endl;
    }
}

方法二，for_each加函数：

template<typename T>
void printer(const T& val)
{
    cout << val << endl;
}
void ShowVec(const vector<int>& valList)
{
    for_each(valList.cbegin(), valList.cend(), printer<int>);
}

方法三，for_each加仿函数：

template<typename T>
struct functor
{
    void operator()(const T& obj)
    {
        cout << obj << endl;
    }
};
void ShowVec(const vector<int>& valList)
{
    for_each(valList.cbegin(), valList.cend(), functor<int>());
}

方法四，for_each加Lambda函数：（注意：lambda为c++11中新增的语义，实则是一个匿名函数）

void ShowVec(const vector<int>& valList)
{
    for_each(valList.cbegin(), valList.cend(), [](const int& val)->void{cout << val << endl; });
}

方法五，for区间遍历：（注意，for区间遍历是c++11新增的语法，用于迭代遍历数据列表）

for (auto val : valList)
{
    cout << val << endl;
}

二分查找的函数

lower_bound(起始地址，结束地址，要查找的数值) 返回的是数值 第一个 出现的位置。

upper_bound(起始地址，结束地址，要查找的数值) 返回的是 第一个大于待查找数值 出现的位置。

binary_search(起始地址，结束地址，要查找的数值) 返回的是是否存在这么一个数，是一个bool值。

注意：使用二分查找的前提是数组有序。

1 函数lower_bound() 参考：有关lower_bound()函数的使用

功能：函数lower_bound()在first和last中的前闭后开区间进行二分查找，返回大于或等于val的第一个元素位置。如果所有元素都小于val，则返回last的位置.

注意：如果所有元素都小于val，则返回last的位置，且last的位置是越界的！！

2 函数upper_bound()

功能：函数upper_bound()返回的在前闭后开区间查找的关键字的上界，返回大于val的第一个元素位置

注意：返回查找元素的最后一个可安插位置，也就是“元素值>查找值”的第一个元素的位置。同样，如果val大于数组中全部元素，返回的是last。(注意：数组下标越界)

PS：

    lower_bound(val):返回容器中第一个值【大于或等于】val的元素的iterator位置。

    upper_bound(val): 返回容器中第一个值【大于】val的元素的iterator位置。

排序函数

自定义排序准则

sort()函数可以自定义排序准则，以便满足不同的排序情况。使用sort()我们不仅仅可以从大到小排或者从小到大排，还可以按照一定的准则进行排序。比如说我们按照每个数的个位进行从大到小排序，我们就可以根据自己的需求来写一个函数作为排序的准则传入到sort()中。

比如每一个学生有四科成绩，我们需要根据学生的四科成绩的平均分高低进行排名，那么这个cmp函数我们就可以定义为：

bool cmp_score(Student x,Student y){
	double average_x,average_y;
	average_x = (x.score[0]+x.score[1]+x.score[2]+x.score[3])/4;
	average_y = (y.score[0]+y.score[1]+y.score[2]+y.score[3])/4;
	return average_x > average_y;
}

完整代码：

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

struct Student{
	string name;
	double score[4];
};

bool cmp_score(Student x,Student y){
	double average_x,average_y;
	average_x = (x.score[0]+x.score[1]+x.score[2]+x.score[3])/4;
	average_y = (y.score[0]+y.score[1]+y.score[2]+y.score[3])/4;
	return average_x > average_y;
}

int main(){
	Student stu[3];
	string n;
	int s;
	for(int i=0;i<3;i++){
		cin>>stu[i].name;
		for(int j=0;j<4;j++){
			cin>>stu[i].score[j];
		}
	}

	sort(stu,stu+3,cmp_score);

	for(int i=0;i<3;i++){
		cout<<stu[i].name<<" ";
		for(int j=0;j<4;j++){
			cout<<stu[i].score[j]<<" ";
		}
		cout<<endl;
	}

	return 0;
}

C++ greater()和less()

1.greater和less是头文件

template <class T> struct greater {
  bool operator() (const T& x, const T& y) const {return x>y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

template <class T> struct less {
  bool operator() (const T& x, const T& y) const {return x<y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

2.在sort()函数中使用greater<>()和less()

#include<iostream>
#include<vector>
#include<iterator>
#include<functional>
#include<algorithm>
using namespace std;

int main()
{
	int A[]={1,4,3,7,10};
	const int N=sizeof(A)/sizeof(int);
	vector<int> vec(A,A+N);
	ostream_iterator<int> output(cout," ");
	cout<<"Vector vec contains:";
	copy(vec.begin(),vec.end(),output);

	cout<<"\nAfter greater<int>():";
	sort(vec.begin(),vec.end(),greater<int>());//内置类型从大到小
	copy(vec.begin(),vec.end(),output);

	cout<<"\nAfter less<int>():";
	sort(vec.begin(),vec.end(),less<int>());   //内置类型小大到大
	copy(vec.begin(),vec.end(),output);

	return 0;
}

C++ find 和 find_if（STL find_if）查找算法详解

1、find

using namespace std;
int main()
{
    list<int> lst;
    lst.push_back(10);
    lst.push_back(20);
    lst.push_back(30);
    list<int>::iterator it = find(lst.begin(), lst.end(), 10); // 查找list中是否有元素“10”
    if (it != lst.end()) // 找到了
    {
        // do something
    }
    else // 没找到
    {
        // do something
    }
    return 0;
}

那么，如果容器里的元素是一个类呢？例如，有list ，其中CPerson类定义如下：

class CPerson
{
public:
    CPerson(void);
    ~CPerson(void);

    bool CPerson::operator==(const CPerson &rhs) const
    {
        return (age == rhs.age);
    }
public:
    int age; // 年龄
};

那么如何用find()函数进行查找呢？这时，我们需要提供一个判断两个CPerson对象“相等”的定义，find()函数才能从一个list中找到与指定的CPerson“相等”的元素。

这个“相等”的定义，是通过重载“==”操作符实现的，我们在CPerson类中添加一个方法，定义为：

bool operator==(const CPerson &rhs) const;

实现为：

bool CPerson::operator==(const CPerson &rhs) const
{
    return (age == rhs.age);
}

然后我们就可以这样查找（假设list中已经有了若干CPerson对象）了：

list<CPerson> lst;
// 向lst中添加元素，此处省略

CPerson cp_to_find; // 要查找的对象
cp_to_find.age = 50;
list<CPerson>::iterator it = find(list.begin(), list.end(), cp_to_find); // 查找

if (it != lst.end()) // 找到了
{
}
else // 没找到
{
}

这样就实现了需求。

2、find_if

有人说，如果我有自己定义的“相等”呢？例如，有一个list<CPerson*>，这个list中的每一个元素都是一个对象的指针，我们要在这个list中查找具有指定age的元素，找到的话就得到对象的指针。

这时候，你不再能像上面的例子那样做，我们需要用到find_if函数，并自己指定predicate function（即find_if函数的第三个参数，请查阅STL手册）。先看看find_if函数的定义：

template<class InputIterator, class Predicate>
InputIterator find_if(InputIterator _First, InputIterator _Last, Predicate _Pred);

Parameters
_First
An input iterator addressing the position of the first element in the range to be searched.
_Last
    An input iterator addressing the position one past the final element in the range to be searched.
_Pred
    User-defined predicate function object that defines the condition to be satisfied by the element being searched for. A predicate takes single argument and returns true or false.

我们在CPerson类外部定义这样一个结构体：

class finder_t
{
public:
    finder_t(int n) : age(n) { }
    bool operator()(CPerson *p)  //注意此处传入类型必须与容器类型一致
    {
        return (age == p->age);
    }
    int age;
}finder_t;

然后就可以利用find_if函数来查找了：

list<CPerson*> lst;
// 向lst中添加元素，此处省略

list<CPerson*>::iterator it = find_if(lst.begin(), lst.end(), finder_t(50)); // 查找年龄为50的人
if (it != lst.end()) // 找到了
{
    cout << "Found person with age : " << (*it)->age;
}
else // 没找到
{
    // do something
}

find_if() 同 find() 一样，为在输入迭代器所定义的范围内查找单个对象的算法，它可以在前两个参数指定的范围内查找可以使第三个参数指定的谓词返回 true 的第一个对象。谓词不能修改传给它的对象。

find_if() 会返回一个指向被找到对象的迭代器，如果没有找到对象，会返回这个 序列的结束迭代器。

可以按如下方式使用 find_if() 来查找 numbers 中第一个大于 value 的元素：

int value {5};
auto iter1 = std::find_if(std::begin(numbers), std::end(numbers),[value](int n) { return n > value; });
if(iter1 != std::end(numbers))
	std::cout << *iter1 << " was found greater than " << value << ".\n";

find_if() 的第三个参数是一个 lambda 表达式的谓词。这个 lambda 表达式以值的方式捕获 value，并在 lambda 参数大于 value 时返回 true。这段代码会找到一个值为 46 的元素。

C++ accumulate函数用法详解

我们已经介绍过 accumulate() 算法的基本版本，可以用 + 运算符求出元素序列的和。前两个参数是定义序列的输入迭代器，第三个参数是和的初值；第三个参数的类型决定了返回值的类型。第二个版本的第 4 个参数是定义应用到总数和元素之间的二元函数对象。这时，我们在必要时可以定义自己的加法运算。例如：

std::vector<int> values {2, 0, 12, 3, 5, 0, 2, 7, 0, 8};
int min {3};
uto sum = std::accumulate(std::begin(values), std::end(values), 0, [min] (int sum, int v){    if(v < min)        return sum;    return sum + v;})；
std::cout << "The sum of the elements greater than " << min-1<<"is " << sum << std::endl;  // 35

这里忽略了值小于 3 的元素。这个条件可以尽可能复杂，因此，我们能够求出指定范围内的元素之和。这个运算并不一定要是加法，可以是任何不修改操作数或不使定义范围的迭代器无效的运算。例如，为数值元素定义的乘法运算函数会生成元素的乘积，只要初值为 1。实现浮点元素除法的函数会生成元素乘积的倒数，只要初值为 1。下面展示了如何生成元素的乘积：

std::vector<int> values {2, 3, 5, 7, 11, 13};
auto product = std::accumulate(std::begin(values), std::end(values), 1, std::multiplies<int>()); // 30030

这里用来自于 functional 头文件的函数作为第 4 个参数。如果有值为 0 的元素，可以像上一个代码段中的 lambda 表达式那样忽略它们。

string 类支持加法，因此可以将 accumulate() 应用到 string 对象的序列上：

std:: vector<string> numbers {"one", "two", "three", "four", "five","six", "seven"，"eight", "nine"，"ten"};
auto s = std::accumulate(std::begin(numbers), std::end(numbers), string{},[](strings str, string& element){    if (element[0] == 't')        return str +' '+ element;    return str;}); // Result: " two three ten"

这段代码连接了以开头的 string 对象，并用空格将它们隔开。acumulate() 算法得到的结果可能和它所应用的序列中的元素类型不同：

std::vector<int> numbers {1, 2, 3, 10, 11, 12};
auto s = std::accumulate(std::begin(numbers), std::end(numbers),string {"The numbers are"},[](strings str, int n){ return str + " : " + std::to_string(n);});
std::cout << s << std::endl;//Output: The numbers are: 1: 2: 3: 10: 11: 12

lambda 表达式使用的 to_string() 函数会返回一个数值参数的 string 形式，所以应用 accumulate() 到这里的整数序列会返回注释中显示的 string。

C/C++中各种类型int、long、double、char表示范围（最大最小值）

#include<iostream>
#include<string>
#include <limits>
using namespace std;

cout << "double: \t" << "所占字节数：" << sizeof(double);
cout << "\t最大值：" << (numeric_limits<double>::max)();
cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;

cout << "float: \t\t" << "所占字节数：" << sizeof(float);
cout << "\t最大值：" << (numeric_limits<float>::max)();
cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;

# C/C++相关函数注意

## atoi()

`atoi()`读到非数字字符则结束转换并将目前已读结果返回