void basic_algo(){
cout<<endl<<"basic_algo :"<<endl;
int ia[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8 };
vector<int> iv1(ia,ia+5); vector<int> iv2(ia,ia+9);
cout<<iv1<<endl<<iv2<<endl;
pair<vector<int>::iterator,vector<int>::iterator> p = mismatch(iv1.begin(),iv1.end(),iv2.begin()); //返回在游标的哪个位置不匹配
if(p.first != iv1.end()) cout<<*(p.first)<<endl;
if(p.second != iv2.end()) cout<<*(p.second)<<endl;
cout<<equal(iv1.begin(),iv1.end(),iv2.begin())<<endl; //比较容器内内容
cout<<equal(iv1.begin(),iv1.end(),&ia[3])<<endl;
cout<<equal(iv1.begin(),iv1.end(),&ia[3],less<int>())<<endl;
fill(iv1.begin(),iv1.end(),9); //区间填充
cout<<iv1<<endl;
fill_n(iv1.begin(), 3, 7); //区间n填充
cout<<iv1<<endl;
vector<int>::iterator iter1,iter2;
iter1 = iter2 = iv1.begin();
advance(iter2,3); //游标向前移动
iter_swap(iter1,iter2); //交换两个游标内容
cout<<iv1<<endl;
swap(*iv1.begin(),*iv2.begin()); //交换两个游标内容
cout<<iv1<<endl<<iv2<<endl;
string stra1[] = {"jk","jK1","jk2"}; string stra2[] = {"jk","jk1","jk3"};
cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2)<<endl;
cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2,greater<string>())<<endl;
copy(iv2.begin()+1,iv2.end(),iv2.begin()); //全部元素向前移一格
cout<<iv2<<endl;
copy_backward(iv2.begin(),iv2.end()-1,iv2.end()); //全部元素向后移一格
cout<<iv2<<endl;
}
void __vector__<_Tp, _Alloc>::_M_range_insert(
__iterator__ __position,
_ForwardIterator __first,
_ForwardIterator __last,
forward_iterator_tag)
# endif /* MEMBER_TEMPLATES */
# if !( defined ( __STL_MEMBER_TEMPLATES ) && defined (__STL_INLINE_MEMBER_TEMPLATES))
{
if (__first != __last) {
size_type __n = 0;
distance(__first, __last, __n);
if (size_type(_M_end_of_storage._M_data - _M_finish) >= __n) {
const size_type __elems_after = _M_finish - __position;
pointer __old_finish = _M_finish;
if (__elems_after > __n) {
uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish);
copy(__first, __last, __position);
}
else {
# if (defined ( __STL_MEMBER_TEMPLATES ) && ! defined (__STL_INLINE_MEMBER_TEMPLATES))
_ForwardIterator __mid = __first;
advance(__mid, __elems_after);
# else
__const_pointer__ __mid = __first + __elems_after;
# endif
uninitialized_copy(__mid, __last, _M_finish);
_M_finish += __n - __elems_after;
uninitialized_copy(__position, __old_finish, _M_finish);
_M_finish += __elems_after;
copy(__first, __mid, __position);
}
}
else {
const size_type __old_size = size();
const size_type __len = __old_size + max(__old_size, __n);
pointer __new_start = _M_end_of_storage.allocate(__len);
pointer __new_finish = __new_start;
__STL_TRY {
__new_finish = uninitialized_copy(_M_start, __position, __new_start);
__new_finish = uninitialized_copy(__first, __last, __new_finish);
__new_finish
= uninitialized_copy(__position, _M_finish, __new_finish);
}
__STL_UNWIND((_Destroy(__new_start,__new_finish),
_M_end_of_storage.deallocate(__new_start,__len)));
_Destroy(_M_start, _M_finish);
_M_end_of_storage.deallocate(_M_start, _M_end_of_storage._M_data - _M_start);
_M_start = __new_start;
_M_finish = __new_finish;
_M_end_of_storage._M_data = __new_start + __len;
}
}
TEST(AlgorithmTest, CopyBackwardsPointers)
{
uint32_t arr[4] = {2, 3, 4, 99};
uint32_t* result = copy_backward(arr, arr + 3, arr + 4);
EXPECT_EQ(arr + 1, result);
EXPECT_EQ(2u, arr[0]);
EXPECT_EQ(2u, arr[1]);
EXPECT_EQ(3u, arr[2]);
EXPECT_EQ(4u, arr[3]);
}
int main ()
{
int result[5];
copy_backward (numbers, numbers + 5, result + 5);
for (int i = 0; i < 5; i++)
cout << numbers[i] << ' ';
cout << endl;
for (i = 0; i < 5; i++)
cout << result[i] << ' ';
cout << endl;
return 0;
}
TEST(AlgorithmTest, CopyBackwardComplexType)
{
BidirectionalTestContainer<ComplexTestType> src(3);
src[0] = 2;
src[1] = 3;
src[2] = 4;
vector<ComplexTestType> dst(4, 0);
vector<ComplexTestType>::Iterator result = copy_backward(src.begin(), src.end(), dst.end() - 1u);
EXPECT_EQ(dst.begin(), result);
EXPECT_EQ(ComplexTestType(2u), dst[0]);
EXPECT_EQ(ComplexTestType(3u), dst[1]);
EXPECT_EQ(ComplexTestType(4u), dst[2]);
EXPECT_EQ(ComplexTestType(0u), dst[3]);
}
TEST(AlgorithmTest, CopyBackwardIntegralType)
{
BidirectionalTestContainer<uint32_t> src(3);
src[0] = 2;
src[1] = 3;
src[2] = 4;
vector<uint_t> dst(4, 0);
vector<uint_t>::Iterator result = copy_backward(src.begin(), src.end(), dst.end()-1u);
EXPECT_EQ(dst.begin(), result);
EXPECT_EQ(2u, dst[0]);
EXPECT_EQ(3u, dst[1]);
EXPECT_EQ(4u, dst[2]);
EXPECT_EQ(0u, dst[3]);
}
int main()
{
vector<string> coll1 = { "Hello", "this", "is", "an", "example" };
list<string> coll2;
// 使用插入式代替赋值式
copy(coll1.cbegin(), coll1.cend(),
back_inserter(coll2));
copy(coll2.cbegin(), coll2.cend(),
ostream_iterator<string>(cout, " "));
cout << endl;
copy(coll1.crbegin(), coll1.crend(),
coll2.begin());
copy(coll2.cbegin(), coll2.cend(),
ostream_iterator<string>(cout, " "));
cout << endl;
// initialize source collection with "..........abcdef.........."
vector<char> source(10, '.');
for (int c = 'a'; c <= 'f'; c++) {
source.push_back(c);
}
source.insert(source.end(), 10, '.');
print_elements(source, "source: ");
// copy all letters three elements in front of the 'a'
vector<char> c1(source.cbegin(), source.cend());
copy(c1.cbegin() + 10, c1.cbegin() + 16, // source range
c1.begin() + 7); // destination range
print_elements(c1, "c1: ");
// 从后向前挨个复制，与上述copy复制的方向相反
vector<char> c2(source.cbegin(), source.cend());
copy_backward(c2.cbegin() + 10, c2.cbegin() + 16, // source range
c2.begin() + 19); // destination range
print_elements(c2, "c2: ");
}
