C++ primer的一些代码

为什么80%的码农都做不了架构师？>>>   

在快速入门中，讲到用for语句进行数值的相加运算。然后自己想了想，能否用STL中的算法完成，于是写了一下：

#include <iostream>
#include <numeric>
using namespace  std;

int main(void)
{
	cout << accumulate(istream_iterator<int>(cin), istream_iterator<int>(), 0) << endl;

	return 0;
}

这里可以达到的效果是：可以输入任意个数值进行运算。当然，请输入int型。

当时，书上讲到类的概念的时候，用到了Sales_item，然后自己写了一下：

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

class Sales_item{
	friend ostream& operator<<(ostream& os, Sales_item& rhs);
	friend istream& operator>>(istream& is, Sales_item& rhs);
public:

	Sales_item(string isbn = "", int bookNum = 0, float bookPrice = 0) :
	  _isbn(isbn)
	  {
		  _bookNum = bookNum;
		  _bookPrice = bookPrice;
		  _bookTotalPrice = bookNum * bookPrice;
	  }


	  Sales_item& operator+(Sales_item &rhs)
	  {
		  if (_isbn != rhs._isbn)
		  {
			  cerr << "can not add two different books" << endl;
			  return *this;
		  }
		  _bookTotalPrice = _bookNum * _bookPrice + rhs._bookNum * rhs._bookPrice;	//防止一本书两个价格
		  _bookNum += rhs._bookNum;

		  return *this;
	  }
private:
	string	_isbn;		//书的序列号
	int		_bookNum;	//书的数量
	float	_bookPrice;	//一本书书的价钱
	float	_bookTotalPrice;	//所有书的价钱
};

ostream& operator<<(ostream& os, Sales_item& rhs)
{
	os << rhs._isbn << " " << rhs._bookNum
		<< " " << rhs._bookPrice << " " << rhs._bookTotalPrice << endl;
	return os;
}
istream& operator>>(istream& is, Sales_item& rhs)
{
	is >> rhs._isbn >> rhs._bookNum >> rhs._bookPrice;
	rhs._bookTotalPrice = rhs._bookNum * rhs._bookPrice;

	return is;
}

int main(void)
{
	Sales_item item1;
	Sales_item item2;
	cin >> item1;
	cin >> item2;
	cout << item1 + item2 << endl;

	return 0;
}

书上有个例子，是list和deque,将偶数和奇数分开存放。然后我准备写成泛型算法，但是不知道back_insert的返回类型是什么，导致无法使用back_insert这一强大的功能：

C++ PRIER 习题9-18：

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <list>
#include <deque>
using namespace std;

template<typename IteratorType, typename T>
void filter(IteratorType beg, IteratorType end, T dst, bool (*func)(int))
{
	while (beg != end)
	{
		if (func(*beg))
		{
			*dst++ = *beg;
		}
		beg++;
	}
}
bool isOdd(int value)
{
	return bool(value % 2);
}

bool isEven(int value)
{
	return !(value % 2);
}

int main(void)
{
	list<int> ilst;
	for (int i = 0; i < 10; i++)
		ilst.push_back(i);
	deque<int> ideq1(10);
	deque<int> ideq2(10);
	filter< list< int >::iterator, deque< int >::iterator >(ilst.begin(), ilst.end(), ideq1.begin(), isOdd);
	filter< list< int >::iterator, deque< int >::iterator >(ilst.begin(), ilst.end(), ideq2.begin(), isEven);

	
	deque<int>::iterator beg1 = ideq1.begin();
	for (; beg1 != ideq1.end(); beg1++)
	{
		cout << *beg1 << " ";
	}
	cout << endl;
	deque<int>::iterator beg2 = ideq2.begin();
	for (; beg2 != ideq2.end(); beg2++)
	{
		cout << *beg2 << " ";
	}
	cout << endl;

	return 0;
}

只能先给ideq1,ideq2分配空间大小。。。。

最后还是写出来了：

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <list>
#include <deque>
using namespace std;

template<typename IteratorType, typename T>
void filter(IteratorType beg, IteratorType end, T dst, bool (*func)(int))
{
	while (beg != end)
	{
		if (func(*beg))
		{
			*dst++ = *beg;
		}
		beg++;
	}
}
bool isOdd(int value)
{
	return bool(value % 2);
}

bool isEven(int value)
{
	return !(value % 2);
}

int main(void)
{
	list<int> ilst;
	for (int i = 0; i < 10; i++)
		ilst.push_back(i);
	deque<int> ideq1;
	deque<int> ideq2;
	filter< list< int >::iterator, back_insert_iterator< deque< int > > >(ilst.begin(), ilst.end(), back_inserter(ideq1), isOdd);
	filter< list< int >::iterator, back_insert_iterator< deque< int > > >(ilst.begin(), ilst.end(), back_inserter(ideq2), isEven);


	deque<int>::iterator beg1 = ideq1.begin();
	for (; beg1 != ideq1.end(); beg1++)
	{
		cout << *beg1 << " ";
	}
	cout << endl;
	deque<int>::iterator beg2 = ideq2.begin();
	for (; beg2 != ideq2.end(); beg2++)
	{
		cout << *beg2 << " ";
	}
	cout << endl;

	return 0;
}

对于习题9-26，也用了泛型算法来写，结果不知道长度如何缩短。。。

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <list>
#include <deque>
using namespace std;

template< typename IteratorType>
void filter( IteratorType beg, IteratorType end, IteratorType dst, bool (*func)(int))
{
	for (; beg != end; beg++)
	{
		if (func(*beg))
			*dst++ = *beg;
	}
}
bool isOdd(int value)
{
	return bool(value % 2);
}

bool isEven(int value)
{
	return !(value % 2);
}

int main(void)
{
	list<int> ilst;
	vector<int> ivec;
	for (int i = 0; i < 10; i++)
	{
		ilst.push_back(i);
		ivec.push_back(i);
	}

	filter(ilst.begin(), ilst.end(), ilst.begin(), isOdd);
	filter(ivec.begin(), ivec.end(), ivec.begin(), isEven);

	list<int>::iterator beg1 = ilst.begin();
	for (; beg1 != ilst.end(); beg1++)
	{
		cout << *beg1 << " ";
	}

	cout << endl;
	vector<int>::iterator beg2 = ivec.begin();
	for (; beg2 != ivec.end(); beg2++)
	{
		cout << *beg2 << " ";
	}
	cout << endl;


	return 0;
}

最后想到了一种折中的方法，把最后一个迭代器返回即可，然后修改的代码如下，虽然没达到泛型算法的完美境界：

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <list>
#include <deque>
#include <algorithm>
using namespace std;

template< typename IteratorType>
IteratorType filter( IteratorType beg, IteratorType end, IteratorType dst, bool (*func)(int))
{
	for (; beg != end; beg++)
	{
		if (func(*beg))
			*dst++ = *beg;
	}
	return dst;
}
bool isOdd(int value)
{
	return bool(value % 2);
}

bool isEven(int value)
{
	return !(value % 2);
}

int main(void)
{
	list<int> ilst;
	vector<int> ivec;
	for (int i = 0; i < 10; i++)
	{
		ilst.push_back(i);
		ivec.push_back(i);
	}

	list<int>::iterator end = filter(ilst.begin(), ilst.end(), ilst.begin(), isOdd);
	ilst.erase(end, ilst.end());
	vector<int>::iterator end2 = filter(ivec.begin(), ivec.end(), ivec.begin(), isEven);
	ivec.erase(end2, ivec.end());

	list<int>::iterator beg1 = ilst.begin();
	for (; beg1 != ilst.end(); beg1++)
	{
		cout << *beg1 << " ";
	}

	cout << endl;
	vector<int>::iterator beg2 = ivec.begin();
	for (; beg2 != ivec.end(); beg2++)
	{
		cout << *beg2 << " ";
	}
	cout << endl;


	return 0;
}

转载于:https://my.oschina.net/voler/blog/152201