博文
泛型数值STL算法(2008-12-15 15:07:00)
摘要:iota(first, last, value)
返回void,对于0 <= n < (last - first),*(first + n) = value + n
accumulate(first, last, init)
返回s,s = init + *first + *(first + 1) + ... + *(last -1)
accumulate(first, last, init, pred)
返回s,s = pred(pred(...pred(pred(init, *first), *(first + 1)),...), *(last - 1))
inner_product(first1, last1, first2, init)
返回s,s = init + *first1 * *first2 + *(first1 + 1) * *(first2 + 1) + ... + *(last1 - 1) * *(first2 + (last1 - first1) - 1)
inner_product(first1, last1, first2, init, pred1, pred2)
返回s,s = init pred1 *first1 pred2 *first2 ...
partial_sum(first, last, result)
返回result+(last-first),对于0 <= n < (last-first),*(result + n) = accumulate(first, first + n, 0)
partial_sum(first, last, result, pred)
返回result+(last-first),对于0 <= n < (last-first),*(result + n) = accumulate(first, first + n, 0, pred)
adjacent_difference(first, last, result)
返回result+(last-first),*result = *first,对于1 <= n < (last-first),*(result + n) = *(f......
SortingSTL算法(2008-12-15 15:05:00)
摘要:sort(first, last)
返回void,对[first, last)排序,要求随机访问迭代器
sort(first, last, comp)
返回void,对[first, last)排序,要求随机访问迭代器,使用comp比较(下略)
stable_sort(first, last)
返回void,稳定的排序,对于相等的元素排序前和排序后不会改变先后关系
stable_sort(first, last, comp)
partial_sort(first, mid, last)
返回void,局部排序,选最小的(mid-first)个元素放在有序的[first, mid)中,[mid, last)中的剩余元素顺序未定义
partial_sort(first, mid, last, comp)
partial_sort_copy(first, last, rfirst, rlast)
返回rfirst+n,n=min{(last-first), (rlast-rfirst)},从[first, last)中选最小的n个元素放在[rfirst, rlast)中
partial_sort_copy(first, last, rfirst, rlast, comp)
is_sorted(first, last)
返回bool,true当[first, last)为升序,否则false
is_sorted(first, last, comp)
nth_element(first, nth, last)
返回void,相当于一次划分,以nth大元素为pivot的一次partition,其中[first, nth)中不存在元素i,*nth < *i,[nth, last)中不存在元素j,*j < *nth,他们中的元素不保证有序
nth_element(first, nth, last, comp)
lower_bound(first, last, value)
返回最远的i,使对于j在[first, i)中 *j < value is true
lower_bound(first, last, value, comp)
upper_bound(fir......
质变STL算法(2008-12-05 14:26:00)
摘要:copy(first, last, result)
返回result+(last-first),拷贝[first, last)到[result, result + (last - first)),注意这些运算符:*result = *first; ++first, ++result
copy_n(first, n, result)
返回result+n,拷贝[first, first + n)到[result, result + n)
copy_backward(first, last, result)
返回result-(last-first),拷贝[first, last)到[result - (last - first), result)
swap(a, b)
返回void,交换a,b
iter_swap(a, b)
返回void,等同于swap(*a, *b)
swap_ranges(first1, last1, first2)
返回first2+(last1-first1),交换区间[first1, last1),[first2, first2 + (last1 - first1))
transform(first, last, result, op)
返回result+(last-first),对于0 <= n < (last - first),*(result + n) = op(*(first + n))
transform(first1, last1, first2, result, bi)
返回result+(last-first),对于0 <= n < (last1 - first1),*(result + n) = bi(*(first1 + n), *(first2 + n))
replace(first, last, old_value, new_value)
返回void,替换[first, last)中*i == old_value的*i = new_value
replace_if(first, last, pred, new_value)
返回void,替换[first, last)中pred(*i) is true的*i......
非质变STL算法(2008-12-03 19:03:00)
摘要:for_each(first, last, pred)
返回pred,对所有i在[first, last)中,执行pred(*i)
find(first, last, value)
返回第一个i在[first, last)中,*i == value
find_if(first, last, pred)
返回第一个i在[first, last)中,pred(*i) is true
adjacent_find(first, last)
返回第一个i, *i == *(i + 1)
adjacent_find(first, last, pred)
返回第一个i, pred(*i, *(i + 1)) is true
find_first_of(first1, last1, first2, last2)
返回第一个i在[first1, last1)中,且*i == *any[first2, last2)
find_first_of(first1, last1, first2, last2, pred)
返回第一个i在[first1, last1)中,且pred(*i, *any[first2, last2)) is true
count(first, last, value)
返回i的个数,*i == value
count(first, last, value, n)
返回void, n = count(first, last, value)
count_if(first, last, pred)
返回i的个数,pred(*i) is true
count_if(first, last, pred, n)
返回void, n = count_if(first, last, pred)
mismatch(first1, last1, first2)
返回第1个pair(i = first1 + n, j = first2 + n),*i != *j
mismatch(first1, last1, first2, pred)
返回第1个pair(i = first1 + n, j = first2 + n),pred(*i, *j) is false
e......
很久没来了,喘个气(2008-09-10 16:15:00)
摘要:对多个资源操作时,一次全部申请(等待),是最简单的防止死锁的方法,一次全申请并不会影响性能,如果占有时间不长的话~
Semaphore是对一种资源可同时占用的数量的描述,即被多少个线程使用,如果最大数为1,就是一个Mutex, binary semaphore~
中秋快乐~~......
幻想中的typeof(2008-07-05 01:16:00)
摘要:我想我的BLOG是不是要改名字了,还是C++相关。
想研究boost::lambda源码,找到这篇文章:http://www.cppblog.com/shifan3/archive/2006/06/09/8334.html 还算写得不错,通俗啊,我写不出这样的文章,本来是带着一个问题去的,就是关于函数对象的返回类型如何确定。嗯,先从我对lambda库实现的想法说起吧。
简单描述,lambda库是用函数对象重新对程序进行编码。什么是程序的编码,程序是什么,C++程序?包括三个方面:面向类类型的表达式(泛型的),函数(包括成员函数)和控制语句(if,then,while等)。lambda的结果是,让‘程序’重新以‘函数’的方式存在。靠,C++语言并不是函数式语言,整个库出来实现函数式,太牛了。
1种幻想,如果lambda获得了成功,成了新的C++标准,那可否从C++语言的层面直接支持函数,比如定义一个函数本身就在定义一个函数对象!。。。不太可能,这需要支持和改变的东西太多了,是彻底的改变,那还要那些函数式语言干嘛~~
转到lambda的实现,那三个方面又是以表达式为核心的,绑定后的函数还是可以构造表达式,控制语句完了还是可以构造表达式。它的最基础的技术就是表达式模板技术。
表达式模板技术又不好一言两语说清楚,我写过一个Vector的表达式模板,有一些感悟。首先,确定构造后的表达式用来干什么,比如数组的表达式,用来数值计算,所以要定义哪些接口,这个接口是自上而下调用的,不管表达式有多复杂,都会自上而下的调用。lambda的表达式目的很明确,用来函数调用,所以要有operator()接口,那么它又多了一条本质,lambda表达式是一个函数对象。那你要问它有多少个参数?返回参数如何确定?多参数应该是不确定的,没有很好的方法,只能是定义足够用那么多,用宏控制,比如我定义最多十个参数的operator(),那就要从operator()(A1)一直定义到operator()(A1,A2,...A10)这么多。返回类型迟一点再说。
然后是设计托管的泛型的运算符类,比如:
template<typename Arg1,typename Arg2>
class Mult
{
Arg1 arg1;
Ar......
C++中的指针(2008-06-28 22:18:00)
摘要:C++的指针有4种:指向数据,指向函数,指向成员数据和指向成员函数;为什么不分两种,指向数据和指向函数,这个前2种和后2种不能一对一。可以这么分,指向非成员和指向成员,指向成员的简称成员指针。以下一一说明。
1,指向数据的指针
非常简单。例如:
int a = 100;
int *p = &a;
cout<<*p<<endl;
2,指向函数的指针
函数名可以看成是一个单身函数对象,取值后是函数的入口地址,如:
void foo(int a)
{
}
foo看成是一个类型是void (int)的单身对象,但是对名字foo取值后,它会退化成相应的指针类型void (*)(int)。注意那个括号不能少。当然如果对foo取地址也是这个类型(取两次?没考虑过~~哇靠~太绝了吧)。
所以指向函数的指针,申明起来比较怪,像这样:
void (*pf)(int) = &foo;
申明一个类型是void (*)(int)的函数指针pf,并初始化为&foo,这里的函数参数类型形式和返回类型要和foo的声明一致。再多一个例子吧:
int foo2(float a,double b)
{
return 0;
}
int (*pf2)(float,double) = &foo2;
函数指针的使用,两种方式:
(*pf)(100);
即,先引用*,打括号,再传实参调用,或者直接,pf(100)。
函数指针的意义:一个函数可以看成是一个策略,对于一个问题,可以采用不同的策略和方法,这种对策略的选择推迟到运行期,即用一个变量保存起来,在程序跑起来的时候,决定使用什么策略,其本质即是动多态,对一个函数的调用延迟到运行时决定。
3,指向成员数据的指针
在要说成员指针之前,要先明确一个概念:名称的受限。C++有一套自己的名称查找机制,一个名称可以是一个类名,对象名,函数名等。受限是指是否用::,->,.中的一种符号作用。
看一般的成员数据访问:
struct A{int a;};
A a;
A* p=&a;
cout<<a.a<<p->a<&l......
Who's my friend[C++友元点滴](2008-06-20 21:13:00)
摘要:我不知道关于C++关键字friend的全部议题有多少,我只对我了解的做个小结。
1,friend申明一个友元
friend一般为一句申明式,它位于一个类的内部,它申明一个类或者一个函数为该类的友元。friend并不是定义一个成员函数,所以friend放在public,protected或者private前都可以,完全是一样的。做为一个友元,即表示在该类或者该函数内部可以访问这个类的私有成员,你和朋友之间是不是应该没有什么隐藏的呢。例子:
class A
{
public:
A(int _a) : a(_a) {}
friend void test(A&);
friend class B;
private:
int a;
};
void test(A& x)
{
x.a=100;//拥有私有成员a的访问权限
}
class B
{
public:
void foo();
};
如果friend申明式为一般的非模板类或者函数,则该处可以为首次申明。对于一个类,只能是申明式,对于函数,可以是它的定义式。
class A
{
public:
A(int _a) : a(_a) {}
friend void test(A& x)
{
x.a = 100;//定义::test()友元函数
}
friend class B;
private:
int a;
};
注意尽管将函数的定义式放在类内部,但它并不是一个成员函数,对于省略受限的定义形式它将成为一个全局函数::test(),当然你也可以申明另外一个类的成员函数为友元,如:
class A
{
public:
A(int _a) : a(_a) {}
friend void B::foo();
private:
int a;......
C++的const关键字(2008-06-09 18:29:00)
摘要:想小结一下const的种种用法和相关知识
1,const修饰数据
见文:const指针和引用
2,const修饰成员函数
表示该成员函数为常量对象调用,首先来看C++的对象和绑定的成员函数是如何实现的。
class A
{
public:
void Test(int _a)
{
a = _a;
}
private:
int a;
};
A::Test(int)是A的成员函数,一个函数是一段可执行代码,它和对象的数据是两回事,它只需要一份拷贝,相当于它们是静态的不变的(static),而非static数据成员是可以有多份拷贝,它们是动态的可变的,它们之间如何关联起来?通过this指针,在成员函数内对成员变量调用时会省略this指针,上面的语句相当于‘this->a = _a’而this指针是如何传进成员函数的?this指针如何传进去这不是程序员关心的,有的编译器通过函数第一个参数,比如上面的A::Test(int)实际上是A::Test(A* this,int);函数参数的压栈顺序是反的,从汇编的角度看,就是通过系统栈传递this指针,当然,有的还会通过寄存器,如何传进去的不用担心,结果是它已经传进去了。所以可以这样理解下面的C++代码:
A a;
a.Test(100);
理解为:
A a;
A::Test(&a,100);
好了,这样理解是最好的了,我们来看const成员函数,如果上面代码中a是常量,看看有什么问题:
const A a;
A::Test(&a,100);
由于Test()的第一个参数是A*,&a的结果是const A*,不能将一个指向常量的指针赋给一个一般指针,编译错误。所以简单在Test定义式中尾部加一个const:
void Test(int _a) const
{
 ......
C++转型操作符(2008-06-06 22:42:00)
摘要:C++有四种转型操作符,以下小结一下:
1,static_cast<>()
用得最多的,如果转换的是类型,则调用转型函数:比如int转float,float转int等基本数据类型的转型,如果是一个类,就调用类型转换函数,比如:
#include <iostream>
using namespace std;
class A
{
public:
explicit A(int _a = 0) : a(_a) {}
operator int() const
{
return a;
}
private:
int a;
};
int main()
{
A a(100);
int b = static_cast<int>(a);
cout<<b<<endl;
system("PAUSE");
return 0;
};
可以转换一个基类指针到子类指针的转型,但是不做动态类型检查,可以不存在虚函数,因此转型可能是不安全的,但是是快速的。
2,dynamic_cast<>()
专门用于C++类的指针转型,且是用于多态继承体系中的类。public继承体现了‘is-a’的类关系,一个基类指针,可以指向子类对象,它的子类类型是动态类型,dynamic_cast<>()就是将基类指针转型成它动态类型的子类指针,如果类型不对,结果就是空。
#include <iostream>
using namespace std;
class B
{
public:
 ......