Dutor » 之语言特性

const在C和C++中的区别

dutor — Tue, 17 Aug 2010 13:50:48 +0000

　　const在C，尤其是C++，是个老生常谈的问题，但这里不谈const具体有哪些特性，如何使用，而是说说const在C和C++中的区别。编译器，C使用gcc，C++使用g++，其它编译器（cl等）请自行验证。
　　在我的印象中，const就是常量（constant）。但这并不是真的。在C中，const仅仅表示其所修饰对象不可修改。常量和所谓“不可修改”有什么区别呢？C中，const int N = 10; 这样的语句声明了一个整型数据，声明之后你不能再为其赋值，此即为不可修改。但在C中，N却不是常量，而诸如372, 3.72, ‘A’之类才是常量，在C中定义常量通常使用#define。而在C++中，const int N = 10; 就会定义N为常量。
　　怎么证明呢？你可能知道，定义静态数组，必须使用整型常量指定其大小，那咱们就用这个特性来验证上面描述的观点。

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N] = { 1, 2, 3 };
    return 0;
}

　　使用g++编译这个程序，没有问题。但若使用gcc，你会得到如下错误信息

main.c: In function ‘main’:
main.c:19: error: variable-sized object may not be initialized
main.c:19: warning: excess elements in array initializer

　　
　　但事情并未到此结束，如果你把上面代码中int a[N] = { 1, 2, 3 };的初始化列表去掉，即int a[N]; 然后就也能通过gcc的编译，更有甚者，如果你把const int N = 10;的const去掉：int N = 10; 也能通过gcc的编译！这是gcc所支持的特性，即动态数组。但最好不要这样做，因为gcc会为此生成大量代码。例如，这段代码

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N];
    return 0;
}

使用gcc生成的汇编代码：

 
	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
	leal	4(%esp), %ecx
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%ebx
	pushl	%ecx
	subl	$60, %esp
	movl	%ecx, %eax
	movl	4(%eax), %eax
	movl	%eax, -44(%ebp)
	movl	%gs:20, %eax
	movl	%eax, -28(%ebp)
[ ... ] # 此处略去n行
	movl	%ecx, %esp
	movl	-28(%ebp), %edx
	xorl	%gs:20, %edx
	je	.L3
	call	__stack_chk_fail
.L3:
	leal	-12(%ebp), %esp
	addl	$0, %esp
	popl	%ecx
	popl	%ebx
	popl	%esi
	popl	%ebp
	leal	-4(%ecx), %esp
	ret

　　整个汇编文件有96行之多。而使用g++（N为常量）编译生成的汇编文件只有23行：

	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$48, %esp
	movl	$10, -4(%ebp)
	movl	$0, %eax
	leave
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
	.section	.note.GNU-stack,"",@progbits

[C/C++]volatile

dutor — Tue, 10 Aug 2010 12:05:25 +0000

volatile

　　可能很多人都没用过C/C++中的这个关键词，甚至不知道它的存在，本人以前也只是有所耳闻，但似懂非懂。
　　这是一个类型修饰符，位置同const、static等。一个使用volatile修饰的变量，比如volatile int i; 每次对该变量的直接引用，都会访问内存，而不是从寄存器中读取（如果其已经在寄存器中）。这样一来，volatile似乎没什么用处，反倒会使数据的读取相对变慢很多。但是，如果没有volatile，编译器可能会优化你的程序，使得数据从寄存器中读取，从而加快程序的运行，但如果这个变量是同其它进程/线程共享的，就可能造成数据的不一致。多线程情况下，你可以使用互斥机制来保证对共享数据访问的原子性。但是，在单片机等嵌入式环境中，硬件经常不会有这种互斥机制的支持，这时某些共享的数据（比如端口）就可能会产生不一致的情况。而使用volatile就会使编译器不对代码进行优化，每次对该变量的访问都会从内存中读取。
　　下面通过观察使用volatile前后编译产生的汇编代码的不同，来加深对volatile关键词的理解。
　　对于下面的C代码：

#include 
 
int foo(void)
{
    int i = 0;
    while(i++ < 20);
    return i;
}
int
main(int argc, char **argv)
{
    int i = foo();
    int j = i;
    int k = i;
    printf("%d, %d, %d\n", i, j, k);
    return 0;
}

　　代码中，使用foo()的返回值（20）来初始化整型变量i。之所以不直接赋值，是为了防止编译器优化，下面对j,k的赋值将直接使用20，而不是i，也不是寄存器。使用下面的命令编译：

1	$ gcc -S -O1 main.c # 优化等级1

　　产生的汇编代码：

[ ... ]
.LC0:
	.string	"%d, %d, %d\n"
[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 16(%esp) # 参数k入栈
	movl	%eax, 12(%esp) # 参数j入栈
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	movl	$1, (%esp)
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

　　可以看到，对j,k的赋值都是由寄存器eax进行的。下面把代码中的int i = foo();换成volatile int i = foo();，编译得到的汇编代码是：

[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 44(%esp) # 为i赋值
	movl	44(%esp), %edx # 读取i值
	movl	44(%esp), %ecx # 读取i值
	movl	44(%esp), %eax # 读取i值
	movl	%ecx, 16(%esp) # 参数k入栈，使用i值
	movl	%edx, 12(%esp) # 参数j入栈，使用i值
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

　　可以看到，每次对i的访问都是从内存（栈）中读取的。

volatile vs. const

　　正像上面所描述的那样，volatile的意思是“易变的”。C/C++中还有另外一个关键词叫const，用来限定变量不可被改变。似乎volatile和const意思相反，水火不容。但volatile const int N = 0;这样的语句是允许存在的。为什么呢？其实，这个语句可以这样来理解：变量N在本程序（或者设备）中是不可（禁止）改变的，但它可能会被其它程序（或者设备）改变。你或许知道，const只是编译器的限定，而没有执行期的检查，因此const也只是限于单个进程，因此volatile和const这两个关键词并不冲突。
　　另外，普通的整型const变量，比如const int N = 10; int a[N]; 中，变量N可能并不会被分配内存（除非程序里面有显式使用N地址的表达式）。但是，根据volatile变量的特性，volatile const int N = 10;中变量N是一定会占用内存的。这一点，亦可以通过观察相应的汇编代码来验证。

qsort

dutor — Tue, 06 Jul 2010 12:57:10 +0000

　　Felix那里看到的，关于用qsort对指针式字符串数组和二维型字符串数组的排序的，觉得值得贴出来。注意下下面两片代码的区别。

const int N = 4;
char *str[N] = { "xyz", "cdef", "abcd", "caaa"};
 
int cmp(const void *l, const void *r)
{
    const char *a = *((char**)l);
    const char *b = *((char**)r);
    return strcmp(a, b);
}
int
main(int argc, char **argv)
{
    qsort( (void*)str, N, sizeof(int*), cmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

const int N = 4;
char str[N][10] = { "xyz", "cdef", "abcd", "caaa"};
 
int
main(int argc, char **argv)
{
    qsort( (void*)str, N,
            sizeof(char)*10,
            ( int(*)(const void*, const void*) )strcmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

　　对qsort需要注意几点：

qsort中第一个参数是待排序数组的开始地址，既然是数组，各元素就是同类型、同大小的对象，且数组是“一维数组”（即地址是连续的）；
qsort用以区分对象的依据是第二和第三个参数，分别表示对象个数和每个对象的大小（字节）；
qsort并不知道每个对象的类型和结构，排序准则由用户在第四个参数（比较函数）中指出，qsort按该比较函数准则的“升序”对数组进行排序；
标准C不支持运算符重载，各对象的交换（因为这是qsort）靠的是逐字节的拷贝（memcpy?）。

　　在上面的两片代码中，待排序的对象一个是字符型指针，一个是char (*)[10]型数组。然后，就没有然后了。
　　
　　然后，上面代码，gcc编译出错，g++却可以。
　　const int N = 4; char *str[N];可以。
　　const int N = 4; char *str[N] = {“a”,”b”,”c”,”d”};却不可，何解？

struct/class关键字何时是必须的？

dutor — Fri, 21 May 2010 13:16:54 +0000

　　在形如struct structName varName;的语句中，struct是必须的吗？这是一个显而易见的语法问题，但却容易被忽略，尤其容易被C+C++的同志们忽略。
　　在标准C中，struct关键字是必须的：

struct structName {
    int n;
};
//~ typedef struct structName structName;
int
main()
{
    struct structName n;
    return 0;
}

若没有前置的struct关键字，上面的代码就不能通过编译。我的gcc会提示”structName” undeclared, parse error before ‘n’的错误。为了方便，通常会使用typedef struct structName structName;语句来为struct structName定义类型别名。
　　但是，在C++中，一般情况下，struct/class关键字就不是必须的。但是，在有些情况下struct/class关键字又是必须的，因为这时的名字structName有歧义性。这是因为，C/C++语言允许用户自定义类型和函数同名。

struct structName {
    int n;
};
void structName() {
    ;
}
int
main()
{
    structName n;
    return 0;
}

上面代码，无论使用gcc还是g++，都不能通过编译，即使structName n;明显只能是一个变量定义语句。这时，就需要明确使用关键字struct，即struct structName n;

[STL]函数对象/仿函数

dutor — Thu, 29 Apr 2010 12:37:46 +0000

　　提到C++ STL，首先被人想到的是它的三大组件：Containers, Iterators, Algorithms，即容器，迭代器和算法。容器为用户提供了常用的数据结构，算法大多是独立于容器的常用的基本算法，迭代器是由容器提供的一种接口，算法通过迭代器来操控容器。接下来要介绍的是另外的一种组件，函数对象（Function Object，JJHou译作Functor仿函数）。

什么是函数对象

　　顾名思义，函数对象首先是一个对象，即某个类的实例。其次，函数对象的行为和函数一致，即是说可以像调用函数一样来使用函数对象，如参数传递、返回值等。这种行为是通过重载类的()操作符来实现的，举例说明之，

class Print
{
public:
    void operator()(int n)
    {
        std::cout<<n<<std::endl;
        return ;
    }
};
int
main(int argc, char **argv)
{
    Print print;
    print(372);
    print.operator()(372); //~ 显式调用
    return 0;
}

　　其实我们早就开始使用函数对象了，当你写下sort(v.begin(), v.end())时(假定v是vector)，其实调用的是sort(v.begin(), v.end(), less())，这样sort就会将v从小至大排序。若要逆向排序，你就需要显式地为sort指定一个排序规则，即函数对象greater(). less和greater是STL中的两个模板类，它们使用类型T的<和>操作符。less的一个典型实现可能是这样的：

template <class T>
class less
{
public:
    bool operator()(const T&l, const T&r)const
    {
        return l < r;
    }
};

函数对象的分类

　　根据用途和参数特征，STL中的函数对象通常分为以下几类：Predicates, Arithmetic Function Objects, Binders, Negaters, Member Function Adapters, Pointer to Function Adapters。下面逐一介绍一下，之前得先介绍两个基类：

template<class Arg, class Res>
struct unary_function //~ 一元函数对象基类
{
   typedef Arg argument_type;
   typedef Res result_type;
};
 
template<class Arg1, class Arg2, class Res>
struct binary_function //~ 二元函数对象基类
{
   typedef Arg1 first_argument_type;
   typedef Arg2 second_argument_type;
   typedef Res  result_type;
};

使用这两个基类，首先需要包含头文件。

Predicates

　　Predicate是一种函数对象，返回值（应该是operator()的返回值）为布尔型，接受一个或者两个参数。通常用来判断对象的有效性（一个参数时）或者对两个对象进行比较（如less）。你可以根据自己的需要定义自己的Predicate，但STL已经定义了一些Predicate，你可以直接使用。

Predicates
Predicate	类型	描述
equal_to()	Binary	使用==判等
not_equal_to()	Binary	使用!=判等
less()	Binary	使用<
greater()	Binary	使用>
less_equal()	Binary	使用<=
greater_equal()	Binary	使用>=
logical_not()	Unary	使用!逻辑取反
logical_and()	Binary	使用&&逻辑与
logical_or()	Binary	使用\|\|逻辑或

算术运算函数对象

　　进行简单的算术运算，这类函数对象我用的很少，通常是自己定义。

算术运算函数对象
函数对象	类型	描述
negate()	Unary	使用-求负
plus()	Binary	使用+加法
minus()	Binary	使用-减法
multiplies()	Binary	使用*乘法
divides()	Binary	使用/除法
modulus()	Binary	使用%求余

绑定Binders

　　有两种绑定bind1st和bind2nd，它们可以将一个二元函数对象的其中一个参数绑定为某个已知的对象，从而得到一个一元函数对象。例如要在vector v中查找等于372的值的位置，我可以将372绑定到equal_to()的第一个或者第二个参数：

int
main(int argc, char **argv)
{
    vector<int> v;
    for(int i = 0; i < 1000; ++i)
    {
        v.push_back(i);
    }
    vector<int>::iterator it;
    it = find_if(v.begin(), v.end(), bind1st(equal_to<int>(), 372));
    std::cout<<*it<<std::endl;
    return 0;
}

　　其实，这里的bind1st和bind2nd并不是函数对象，只是模板函数而已。这两个函数分别返回类型为binder1st和binder2nd的函数对象。下面的代码，聪明的你肯定一看就懂：

// bind1st
template<class Op> 
class binder1st : public unary_function
                  <typename Op::second_argument_type,
                   typename Op::result_type>
{
   Op op_;
   typename Op::first_argument_type first_arg_;
 
   public:
      binder1st(const Op& op,
                const typename Op::first_argument_type&
                first_arg) : op_(op),
               first_arg_(first_arg) {}
 
   typename Op::result_type operator()
      (const typename Op::second_argument_type& arg) const
   {
      return op_(first_arg_, arg);
   }
};
 
template<class Op, class Arg>
inline binder1st<Op> bind1st(const Op& op,
                             const Arg& arg)
{
   return binder1st<Op>(op, arg);
}
 
// bind2nd
template<class Op>
class binder2nd : public unary_function
   <typename Op::first_argument_type,
    typename Op::result_type>
{
   Op op_;
   typename Op::second_argument_type second_arg_;
 
   public:
      binder2nd(const Op& op,
                const typename Op::second_argument_type&
                                   second_arg) : op_(op),
                                   second_arg_(second_arg) {}
 
   typename Op::result_type operator()(const typename
      Op::argument_type& arg) const
   {
      return op_(arg, second_arg_);
   }
};
 
template<class Op, class Arg>
inline binder2nd<Op> bind2nd(const Op& op,
                             const Arg& arg)
{
   return binder2nd<Op>(op, arg);
}

Negaters

　　Negater是针对Predicate设计的，它简单的将Predicate的返回值取反。有两个Negater，not1和not2，分别对一元和二元Predicate取反。

Member Function Adapters

　　有时候，你可能想让算法调用容器元素的成员函数，而不是外部函数。因为外部无法改变对象内的状态，且内部函数通常具有更高的效率。例如swap(string, string)总是没有string.swap(string)快速。又比如sort无法对list进行排序，这时候只能使用list.sort()来给链表排序。这时候就需要使用一定的方法将对象内部的函数“变成”函数对象，这样的函数对象叫做成员函数适配器，其实前面的binder也是一种适配器。看下面的例子：

int
main(int argc, char **argv)
{
    vector<list<int> > v;
    v.push_back(list<int>());
    vector<list<int> >::iterator it;
    for(it = v.begin(); it != v.end(); ++it)
    {
        for(int i = 0; i < 20; ++i)
        {
            (*it).insert((*it).begin(), i);
        }
    }
    for_each(v.begin(), v.end(), std::mem_fun_ref(&list<int>::sort));
    for(it = v.begin(); it != v.end(); ++it)
    {
        for(list<int>::iterator lt; lt != (*it).end(); ++lt)
        {
            std::cout<<*lt<<std::endl;
        }
    }
    return 0;
}

上面的例子中，遍历vector >并对链表进行排序。其中使用的是成员函数适配器mem_fun_ref，它返回的函数对象会以list对象的引用为参数。另外一个mem_fun则是以指向list对象的指针为参数。

[C++]exit & abort & 析构 & 异常

dutor — Mon, 26 Apr 2010 12:20:46 +0000

进程之死

　　对于一个用C++写的程序，被加载至内存后运行，最终走向死亡。程序的死亡大致有三种：

自然死亡，即无疾而终，通常就是main()中的一个return 0;
自杀，当程序发现自己再活下去已经没有任何意义时，通常会选择自杀。当然，这种自杀也是一种请求式的自杀，即请求OS将自己毙掉。有两种方式：void exit(int status)和void abort(void)。
他杀，同现实不同的是，程序家族中的他杀行径往往是由自己至亲完成的，通常这个至亲就是他的生身父亲（还是母亲？）。C++并没有提供他杀的凶器，这些凶器往往是由OS直接或者间接（通过一些进程库，如pthread）提供的。

　　自然死是最完美的结局，他杀是我们最不愿意看到的，自杀虽是迫不得已，但主动权毕竟还是由程序自己掌控的。下面探究程序一下不同的死亡方式对对象的析构有何影响。

程序死亡方式对对象析构的影响

　　C++程序中大致有三种对象：全局对象、局部静态对象、局部非静态对象（自动对象）。举例说明之：

#include 
using namespace std;
 
struct Foo
{
    Foo(){ cout<<"Foo"<<endl; }
    ~Foo(){ cout<<"~Foo"<<endl; }
    /* some other sources here */
};
Foo Global;
void quit();
int
main()
{
    static Foo StaticLocal;
    Foo Local;
    //~ quit();
    //~ abort();
    return 0;
}
void quit()
{
    Foo AnotherLocal;
    exit(1);
}

　　编译运行这个程序，程序将正常退出。运行过程中，Global对象在进入main之前首先被构造，其次是StaticLocal和Local。main函数退出之前，Local和StaticLocal被析构，main退出后Global也将被析构。
　　如果将17行处quit()的注释去掉，我们将会看到4个对象被构造，但却只有两个对象被析构，分别是Global和StaticLocal对象，其他两个对象Local和AnotherLocal对象的析构函数将不会被调用。
　　如果将18行处abort()的注释去掉（quit()被注释），3个对象对象被构造，但在程序退出之前没有任何一个对象的析构函数被调用。
　　也就是说，正常情况下，所有类型的对象都将被析构；由exit退出时只有非自动对象被析构；abort被调用时，程序将直接退出，任何对象的析构函数都不会调用。下面着重介绍下exit的行为。

exit做了什么

　　介绍exit之前，不得不提void atexit(void (*f)(void) )函数。atexit，顾名思义，它描述了exit里面要做些什么。可以看出，它接受一个void f(void)形式的函数的指针。使用atexit我们可以向exit注册一些列的函数，这些函数在exit中被调用，调用的顺序与它们被注册的顺序相反。你可以使用下面的代码来验证：

#include 
using namespace std;
 
void f1(){ cout<<"f1"<<endl; }
void f2(){ cout<<"f2"<<endl; }
int
main()
{
    atexit(f1);
    atexit(f2);
    exit(1);
    return 0;
}

　　void exit(int status)被调用时，它首先调用全局的或者静态的对象的析构函数，然后调用atexit所注册的函数。如果这些函数中的某一个再次调用exit，your nightmare is coming。最后，exit会将代表程序执行状态的status“返回”（确切的说应该叫做传递，因为exit永远不会返回调用方）给当前程序的父进程。
　　值得一提的是，执行exit结束程序，虽然自动对象的析构函数不被调用，但当程序结束时，OS会将该程序占用的资源全部释放。这些资源包括该程序申请的内存（堆）、打开的文件句柄、管道（Unix/Linux）、socket等。这样一来，似乎那些析构函数不被调用并不会有什么问题。确实，但可惜这只适用于单线程的程序。对于多线程程序来说，只有当整个进程结束时，它占用的资源才会被OS释放，这时某个线程的exit就可能带来麻烦（比如内存泄露）。怎么办呢？

使用异常

　　使用C++提供的异常机制，可以很好的解决上面提出的问题。我们可以在需要exit的地方抛出（throw）异常，然后在捕获（catch）异常处调用exit，这样，所有需要的析构函数都将被调用。代码通常是这个样子滴：

#include 
#include 
using namespace std;
 
struct Foo
{
    Foo(){ cout<<"Foo"<<endl; }
    ~Foo(){ cout<<"~Foo"<<endl; }
    /* some other sources here */
};
struct except: public exception
{
    const char* what() const throw()
    {
        return "except";
    }
};
 
Foo Global;
void quit();
int
main()
{
    try
    {
        static Foo StaticLocal;
        Foo Local;
        quit();
    }
    catch(const exception& e)
    {
        cerr<<e.what()<<endl;
        exit(0);
    }
    return 0;
}
void quit()
{
    Foo AnotherLocal;
    //~ exit(1);
    throw except();
}

输出：

Foo
Foo
Foo
Foo
~Foo
~Foo
except
~Foo
~Foo

补充：还有一个与atexit()相似的函数叫on_exit()，Google之。

[C++]覆盖std内的名字

dutor — Tue, 20 Apr 2010 08:07:08 +0000

　　在现行的C++标准中有这么一个名字，std，它是一个namespace(命名空间)。C++标准库的所有类型/对象/函数/模板都定义在这个命名空间中。关于”What namespace? Why namespace? How namespace?” 的问题，任何一本基础的C++读物中都会有介绍，此处略过。为了使用std内定义的对象，可供使用的语法无非是

std::vector<int> ivec;
//~ or
using std::vector;
vector<int> ivec;
//~ or
using namespace std;
vector<int> ivec;

　　现在有这样一种需要，我想为std内的某种类型(比如string)重载操作符，而不想使用std内为我们提供的版本。很简单：

#include 
#include 
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r; //~ 逆天而行了 :-)
}
int
main(int argc, char **argv)
{
    cout<<string("dutor")<string("ivan")<<endl;
    return 0;
}

　　运行这段代码，确实会得到我们想要的结果，dutor > ivan. 但是对于std内其他使用string的operator<()的对象还会这样吗？

#include 
#include 
#include 
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r;
}
int
main(int argc, char **argv)
{
    set<string> Set;
    Set.insert("ivan");
    Set.insert("dutor");
    for(set<string>::iterator it = Set.begin();
            it != Set.end(); ++it)
    {
        cout<<*it<<endl;
    }
    return 0;
}

　　这次ivan会在dutor前面输出吗？很遗憾，dutor被首先输出。不要忘了，std内还有一个operator<(const string&, const string&)呢！set调用的正是std里面的版本！那么我们有什么办法可以让set调用我们自己的operator<()呢？这涉及到C++的名字查找机制，C++采用的是一种懒惰的名字查找机制，也可以说是一种非贪婪式的查找。以本例来说，set与原始版本的operator<同属于std命名空间，set就会就近使用这个版本，而不是我们的自定义版本，而我们在main中使用的却是自定义版本。
　　现在如何让set使用自定义的operator<已经变得明朗了，我们仅仅需要把我们的这个operator<添加到std中：

namespace std{
    bool operator<(const string& l, const string& r)
    {
        return l > r;
    }
}

　　关于C++的名字查找机制，这里提到的只是皮毛而已，很多参考资料中到都做了深入的描述，请自行查阅。

　　刚才在当当买书，又看到雷人的一幕（我为什么说又？）：

实在想不通，这￥0.56是哪里来的？

Visual Studio中的Functional

dutor — Sun, 18 Apr 2010 09:04:46 +0000

　　今天在VS中遇到一个十分诡异的事情，先看下面这个简单的程序：

#include 
#include 
#include 
using namespace std;
class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ 此间内容可略去不看。
		//~ 如果l和r含有的digits完全相同则返回false,
		//~ 如125 vs. 512
		char tmp1[1024], tmp2[1024];
		sprintf(tmp1,"%ld",l);
		sprintf(tmp2,"%ld",r);
		sort(tmp1, tmp1+strlen(tmp1));
		sort(tmp2, tmp2+strlen(tmp2));
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
		return true;
	}
};
int main(int argc, char* argv[])
{
	set<long long,cmp > Set;
	int a[15];
	Set.insert(1);
	Set.insert(2); //~ 此处疯狂
	return 0;
}

　　程序在这个地方跑偏了，弹出这么个东西

　　可是set的key_compare我一直都是这么用的啊。把程序拷到Linux下面用g++就一切正常。望达人指教。

更新

　　Johnny同学给的贴文中提到了，一个predicate对于任两个参数a,b不能返回两个true，即pred(a, b)和pred(b, a)不能同时返回true，这是strict weak规则决定的。代码为证：

template<class _Pr, class _Ty1, class _Ty2> inline
    bool __CLRCALL_OR_CDECL _Debug_lt_pred(_Pr _Pred, _Ty1& _Left, _Ty2& _Right,
        const wchar_t *_Where, unsigned int _Line)
    {    // test if _Pred(_Left, _Right)  and _Pred is strict weak ordering
    if (!_Pred (_Left, _Right))
        return (false);
    else if (_Pred(_Right, _Left))
        _DEBUG_ERROR2("invalid operator<", _Where, _Line);
    return (true);
    }

　　即是说，在调试时（特指Visual Studio的debug模式），bool _Debug_lt_pred()模板函数会对pred(a, b)的返回结果进行检查。如果pred(a, b)返回false没有问题。但如果其返回true，那么_Debug_lt_pred还会对pred(b, a)进行检查，若也返回true就会触发assert（有上图为证）。
　　对于本文最初的代码，为了通过的_Debug_lt_pred的检查，我可以：

class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ ……
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
                else
		        return l < r;
	}
};

这样就保证了cmp::(long long, long long)不会返回“两个true”了

[C++]优先级队列priority_queque

dutor — Sat, 27 Mar 2010 11:15:59 +0000

　　好久没写C++没用STL了，今天在STLChina泡了一下午。完整的代码只写了这么一个，贴上来吧。
　　写了两个类，Max_Heap和Min_Heap，以他们特例化priority_queue，可以方便地实现最大、最小堆。写完了忽然又觉得这俩类似乎是多此一举了，完全可以用greater来实现最小堆，但由priority_queue的模板定义看出，那样就必须提供一个容器类型，比如vector。
　　最后还写了测试用例：找出ｎ个数中最大的k个。

/*
template < class T, class Container = vector,
           class Compare = less > class priority_queue;
 
explicit priority_queue ( const Compare& x = Compare(),
                          const Container& y = Container() );
template 
         priority_queue ( InputIterator first, InputIterator last,
                          const Compare& x = Compare(),
                          const Container& y = Container() );
*/
#include 
#include 
using namespace std;
 
struct Max_Heap
{
    Max_Heap(int n): _n(n) {}
    operator int() { return _n;} //在需要的地方隐式类型转换
    int _n;
};
 
struct Min_Heap
{
    Min_Heap(int n): _n(n) {}
    operator int() { return _n;} //在需要的地方隐式类型转换
    int _n;
};
bool operator < (Max_Heap l, Max_Heap r) //~ 正常的<
{
    return l._n < r._n;
}
 
bool operator < (Min_Heap l, Min_Heap r) //~ 反义的<
{
    return l._n > r._n;
}
 
int
main (int argc, char **argv)
{
    priority_queue<Min_Heap> heap; //~ 最小堆
    //priority_queue heap; //~ 最大堆
    //~ 测试用例
    //~ 前K个最大值
    int k = 5;
    int tmp;
    for (int i = 0; i < k; ++i)
    {
        cin>>tmp;
        heap.push(tmp);
    }
    while (cin>>tmp)
    {
        if(tmp > heap.top()._n)
        {
            heap.push(tmp);
            heap.pop();
        }
    }
    cin.clear();
    while (heap.size())
    {
        cout<<heap.top()._n<<' ';
        heap.pop();
    }
    return 0;
}

一个关于大小端的问题

dutor — Sun, 14 Mar 2010 09:14:59 +0000

　　所谓大小端模式，就是一个关于数据字节在存储顺序的问题。在某些编程环境中，了解大小端是非常重要的，比如汇编和网络编程中，对存取和发送、接收数据的字节序都有严格的要求。当然，在高层次，你很少会需要考虑到这些。为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节。在许多计算机语言中，许多数据类型都是多字节的，这就产生了多字节数据在内存中存放数据的问题。在大端模式（Big-endian）中，数据的低位（就是权值较小的后面那几位）保存在内存的高地址中，而数据的高位，保存在内存的低地址中；在小端模式（Little-endian）中，数据低位就存放在内存的低位。了解了什么是大小端，看下面的程序，输出结果是什么？

#include 
int
main()
{
    int a[] = {1, 2, 3, 4, 5};
    int *ptr1 = (int*) (&a + 1) - 1;
    int *ptr2 = (int*) ((int)a + 1);
    printf("%x, %x\n", *ptr1, *ptr2);
    return 0;
}

　　在我的机器上的输出时5, 2000000，可以看出是处理器是小端模式的。为什么呢？
　　首先*ptr1 == 5是没有疑问的。
　　再看看，*ptr2：

内存编号	0	1	2	3	4	……
数据内容(16进制)	0×01	0×00	0×00	0×00	0×02	……

　　指针ptr2指向1号单元，因此*ptr2就是0×02000000。在大端模式的机器中内存布局应该是这样滴：

内存编号	0	1	2	3	4	……
数据内容(16进制)	0×00	0×00	0×00	0×01	0×00	……

[C++]虚静态函数

dutor — Sat, 06 Mar 2010 10:44:28 +0000

　　C++类的静态函数是属于类型的，而不是某个对象的，因此把它声明成Virtual也没什么实际意义。那么运行下面这段程序，会产生什么样的结果呢？

#include 
using namespace std;
class Base
{
public:
    static void foo() { cout<<"Base"<<endl; }
    virtual void bar() { foo(); }
};
class Derived: public Base
{
public:
    static void foo() { cout<<"Derived"<<endl; }
    virtual void bar() { foo(); }
};
int main
{
    Base * p = new Derived;
    p->bar();
    delete p;
    return 0;
}

[Tricks]C++成员函数和静态变量

dutor — Sun, 21 Feb 2010 15:34:18 +0000

　　想一下，下面的代码片段会输出什么？

#include 
class Test
{
public:
    void print() const
    {
        std::cout<<_int<<std::endl;
    }
private:
    static int _int;
};
int Test::_int = 0;
int
main(int argc, char **argv)
{
    Test TArray[10];
    TArray[100].print();
    return 0;
}

　　May you note something, anyhow.

char & * & []

dutor — Sat, 28 Nov 2009 14:12:45 +0000

void fun1(char * str) {}
void fun2(char ** str) {}
 
//~ int main(int argc, char ** argv)
int main(int argc, char * argv[])
{
	char str1[] = "Hello, Piggy!";
	char str2[][4] = "Hello, Piggy!";
	fun1(str1);
	fun2(str2);
	fun2(&str1);
	return 0;
}

　　上面的snippet有错误吗？有几个？你能找出来并说出原因吗？4、5两行有区别吗？想一下，然后看gcc给出的错误信息，

test.c: In function ‘main’:
test.c:9: error: invalid initializer
test.c:11: warning: passing argument 1 of ‘fun2’ from incompatible pointer type
test.c:4: note: expected ‘char **’ but argument is of type ‘char (*)[4]’
test.c:12: warning: passing argument 1 of ‘fun2’ from incompatible pointer type
test.c:4: note: expected ‘char **’ but argument is of type ‘char (*)[14]’

内存泄漏小陷阱

dutor — Wed, 18 Nov 2009 04:36:20 +0000

int
main()
{
	char * str = new char[32];
	str = "Hello, Piggy!";
	return 0;
}

这样是会内存泄漏的……而我一直都不知道……

.LC0:
	.string	"Hello, Piggy!"
	.text
.globl main
	.type	main, @function
main:
	andl	$-16, %esp
	subl	$32, %esp
	movl	$32, (%esp)
	call	_Znaj
	movl	%eax, 28(%esp)
	movl	$.LC0, 28(%esp) ;把str给覆盖了

不过想来也自然，因为这样是允许的，char *str = “Hello, Piggy!”;，“程序中的字符串被存放在常量存储区”不要把这句话当成耳旁风，谨记。

关于内联的疑问

dutor — Fri, 13 Nov 2009 23:35:12 +0000

　　看Chris对内联的总结，说到内联函数在编译时会被放入”符号表”，想一探究竟，结果却发现另外一个问题，疑惑不解。

#include 
inline int add(int a, int b) { return a + b; }
int main()
{
	int n = add(1,2);
	return 0;
}

1 2	$ g++ -otest test.cpp $ objdump ./test -d

08048494 :
 8048494:	55                   	push   %ebp
 8048495:	89 e5                	mov    %esp,%ebp
 8048497:	83 e4 f0             	and    $0xfffffff0,%esp
 804849a:	83 ec 20             	sub    $0x20,%esp
 804849d:	c7 44 24 04 02 00 00 	movl   $0x2,0x4(%esp)
 80484a4:	00 
 80484a5:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 80484ac:	e8 0b 00 00 00       	call   80484bc <_Z3addii>
 80484b1:	89 44 24 1c          	mov    %eax,0x1c(%esp)
 80484b5:	b8 00 00 00 00       	mov    $0x0,%eax
 80484ba:	c9                   	leave  
 80484bb:	c3                   	ret    
 
080484bc <_Z3addii>:
 80484bc:	55                   	push   %ebp
 80484bd:	89 e5                	mov    %esp,%ebp
 80484bf:	8b 45 0c             	mov    0xc(%ebp),%eax
 80484c2:	8b 55 08             	mov    0x8(%ebp),%edx
 80484c5:	8d 04 02             	lea    (%edx,%eax,1),%eax
 80484c8:	5d                   	pop    %ebp
 80484c9:	c3                   	ret    
 80484ca:	90                   	nop
 80484cb:	90                   	nop

　　inline int add(int, int)没有内联，不解。另外，符号表里面也仅仅找到了_Z3addii，我不理解，干嘛把它放进符号表？我想这里的符号表不应该是熟知的那个符号表吧，应该只是编译期的一块用来inline的临时单元。

Go！！！

dutor — Thu, 12 Nov 2009 03:09:40 +0000

　　就在刚刚过去的2009年11月11日，举国欢庆的光棍节，Google推出了一个全新的系统编程语言Go Program Language. ……Simple……Fast……Safe……Concurrent……Funny……Open Source……似乎很牛B的样子，观望……期待……祝福

package main

import "fmt"

func main() {
  fmt.Printf("Hello, 世界\n")
}

Language Talk Show,

C++模板为什么不能分离式编译

dutor — Sat, 07 Nov 2009 13:44:21 +0000

　　对于多个C++编译单元，总是先编译器独立编译各个.cpp生成对应到目标文件.o或者.obj，然后再由链接器将各个目标文件进行链接从而得到最终的可执行文件(PE or ELF)。其实，.o和.obj和最终的可执行文件的格式已经是一样的了，只是其内部可能还有未解析的符号，而且地址也还是相对地址，链接时对未解析的外部符号进行地址替换，同时进行地址重定位，生成虚拟地址空间的可执行二进制代码文件。

// test.h
void f(int);
// test.cpp
#include "test.h"
void f(int n)
{
	// do sthg.
}
// main.cpp
#include "test.h"
int
main()
{
	f(1);
	f(10);
	return 0;
}

1 2	$ g++ test.cpp main.cpp -c $ g++ test.o main.o -o main

　　这里，编译main.cpp生成main.o时发现无法找到f到定义，就把它当作外部符号填入外部符号表，等待链接时确定其地址。而f(1); f(10); 通常是对应两条jmp 0x****h指令(当然还有参数的压栈操作)，0x****h地址处通常就是一条call f; (C++还会对f进行mangling处理)。这样链接器在链接main.o和test.o时，从test.o到导出符号表(或者内部符号表?)中找到f，得到对应的地址(每个符号对应一个偏移地址)，用这个地址替换f，再进行其他的一些必要的重定位，一个可执行文件就形成了。
　　说了这么多，那么C++模板为什么不能分离式编译呢？

// template.h
template <class T>
void f(T t);
// template.cpp
#include "template.h"
template <class T>
void f(T t)
{
	// do sthg.
	T tt;
}
// main.cpp
#include "template.h"
int
main()
{
	f(10);
	f(1.0);
	return 0;
}

1 2	$ g++ template.cpp main.cpp -c $ g++ template.o main.o -o main

　　这里，g++会提示：

main.o: In function `main':
main.cpp:(.text+0x11): undefined reference to `void f(int)'

用

1	$ readelf template.o -d

反汇编也没有任何输出，说明template.o的.text段中一行代码都没有生成。问题就在这里，因为只有当模板函数被调用时编译器才会其实例化，为其生成代码。又由于template.cpp是独立编译的，它看不到main.cpp对f(T t)的调用，因此没有实例化的f(int)代码生成。如果将template.cpp加入template.h，f(10)和f(1.0)就会分别被实例化为f(int)和f(double)，一切都恢复正常。

over~~~

？？？我写这些干吗？God knows.
Bayes theorem 真的很牛B，很神奇。

sizeof只是个运算符

dutor — Thu, 05 Nov 2009 04:35:05 +0000

　　有的东西，你自己觉得自己理解了知道了记住了，可能你真的记住了，但你真的理解了吗？Put a “Why” upon everything ever you touch.
　　sizeof仅仅是个运算符，但那又意味着什么呢？意味着它不是一个函数，意味着它是在编译期求值(我并不是说所有的运算符都编译期求值)的。对于这样一条语句：

1	size_t size = sizeof(int);

来说，仅仅对应着这样一条汇编指令：

1	movl $4, -4(%ebp)

　　这对于自定义类型class也是同样的。

一段小程序

dutor — Tue, 03 Nov 2009 04:40:13 +0000

一、
源程序，

int
main()
{
	unsigned a = 1;
	int b = 1;
	while(a + b >= 0) --b;
	return 0;
}

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
.L2:
	subl	$1, -8(%ebp)
	jmp	.L2

二、
源程序，

1
2
3

//...
	while(a + b > 0) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

三、
源程序，

1
2
3

//...
	while(a + b > -2) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-1, %eax
	sete	%al
	testb	%al, %al
	jne	.L3

四、
源程序，

1
2
3

//...
	while(a + b >= -2) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-3, %eax
	seta	%al
	testb	%al, %al
	jne	.L3

五、
源代码，

1
2
3

//...
	while(a + b >= 1) --b;
//...

汇编后，

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

　　
　　这里面猫腻儿还真不少。

　　karmic到源里面没有以前到vim-full包了，取而代之到是vim包，但现在有很多问题，n”+yy和n”+p无法和系统”剪切板”里到内容关联了，不知道什么原因。

Update
　　一切都释然了，只要意识到，>也需要进行类型提升。那么后面到-1啦-2啦之类的，都是很大很大的数了，循环根本就进不去，更别提死循环了。这样看来四、五两段程序就没有必要列出来了。其实，我是被它们的汇编代码给迷惑住了。

还是虚存

dutor — Sun, 01 Nov 2009 08:14:09 +0000

　　看这个简单的程序：

#include 
using namespace std;
int
main()
{
    const int size = 2^30;
    char * p = new char[size];
    for(int i = 0; i < size; ++i)
    {
        p[i] = 0;
    }
    sleep(121);
    return 0;
}

　　在后台运行该程序的多个实例，并查看内存占用：

[04:07 PM] ivan@ivan-desktop ~/cpp> ./test&
[1] 8345
[04:07 PM] ivan@ivan-desktop ~/cpp> ./test&
[2] 8346
[04:07 PM] ivan@ivan-desktop ~/cpp> ./test&
[3] 8347
[04:07 PM] ivan@ivan-desktop ~/cpp> ./test&
[4] 8348
[04:07 PM] ivan@ivan-desktop ~/cpp> free

             total       used       free     shared    buffers     cached
Mem:       1997172    1942672      54500          0     486080    1067476

　　只占了十分之一左右！这又是为什么呢？永远也学不完的虚拟内存啊！

　　呃……又SB了！const int size = 2^30;这哪里是1G啊！分明是28嘛！Orz…汇编码里面尽是28！这下好了，改成1<<30，运行了四个实例，机器就笨的像猪了：

System Monitor

　　等程序结束了，刚开始运行着到浏览器也慢了一会儿，估计是被换到交换文件里面去了。

fstream二进制形式读取文件

dutor — Wed, 30 Sep 2009 02:16:26 +0000

我试图以二进制的方式打开文件movie.avi，并复制到另外一个文件film.avi，于是写了下面的一段代码。问题是，这段代码只对某些文件适用，而无法”完全”复制另外一些文件，也就是说，当源文件并没有读完时却已经提前结束了。我想应该是某一个特殊字节的值导致read认为文件已经读完了，但我是以二进制方式打开的文件呀，这种情况下，文件结束符EOF还有意义吗？puzzling……

int
main()
{
    char buf[4096];
    ofstream out("film.avi" );
    ifstream in("movie.avi", ios::binary);
    // ifstream in("movie.rmvb");
    while(1)
    {
        in.read(buf, sizeof(buf));
        out.write(buf, in.gcount());
        if(in.gcount() < sizeof(buf)) break;
    }
    in.close();
    out.close();
    return 0;
}

线程消息队列

dutor — Sat, 22 Aug 2009 10:09:54 +0000

减少pthread_cond_signal和sem_post的调用，只在有必要的时候调用；
尽量避免pthread_mutex进入竞争态。增大消息队列的大小，可以有效减少竞态条件的出现。

#include 
#include 
class CThreadQueue
{
public:
    CThreadQueue (int queueSize = 1024):
  sizeQueue (queueSize), lput (0), lget (0), nFullThread (0),
      nEmptyThread (0), nData (0)
  {
      pthread_mutex_init (&mux, 0);
      pthread_cond_init (&condGet, 0);
      pthread_cond_init (&condPut, 0);
      buffer = new void *[sizeQueue];
  }
  virtual ~ CThreadQueue ()
  {
      pthread_mutex_destroy (&mux);
      pthread_cond_destroy (&condGet);
      pthread_cond_destroy (&condPut);
      delete[]buffer;
  }
  void *getq ()
  {
      void *data;
      pthread_mutex_lock (&mux);
      /*
       * 此处循环判断的原因如下：假设2个线程在getq阻塞，然后两者都被激活，
       * 而其中一个线程运行比较块，快速消耗了2个数据，
       * 另一个线程醒来的时候已经没有新数据可以消耗了。
       * 另一点，man pthread_cond_wait可以看到，
       * 该函数可以被信号中断返回，此时返回EINTR。
       * 为避免以上任何一点，都必须醒来后再次判断睡眠条件。
       * 更正：pthread_cond_wait是信号安全的系统调用，不会被信号中断。
       */
      while (lget == lput && nData == 0)
      {
        nEmptyThread++;
        pthread_cond_wait (&condGet, &mux);
        nEmptyThread--;
      }
 
      data = buffer[lget++];
      nData--;
      if (lget == sizeQueue)
      {
        lget = 0;
      }
      if (nFullThread)                  //必要时才进行signal操作，勿总是signal
      {
        pthread_cond_signal (&condPut);
      }
      pthread_mutex_unlock (&mux);
      return data;
  }
  void putq (void *data)
  {
      pthread_mutex_lock (&mux);
      while (lput == lget && nData)
      {
        nFullThread++;
        pthread_cond_wait (&condPut, &mux);
        nFullThread--;
      }
      buffer[lput++] = data;
      nData++;
      if (lput == sizeQueue)
      {
        lput = 0;
      }
      if (nEmptyThread)
      {
        pthread_cond_signal (&condGet);
      }
      pthread_mutex_unlock (&mux);
  }
private:
  pthread_mutex_t mux;
  pthread_cond_t condGet;
  pthread_cond_t condPut;
 
  void **buffer;                        //循环消息队列
  int sizeQueue;                        //队列大小
  int lput;                                    //location put  放数据的指针偏移
  int lget;                                    //location get  取数据的指针偏移
  int nFullThread;                        //队列满，阻塞在putq处的线程数
  int nEmptyThread;                        //队列空，阻塞在getq处的线程数
  int nData;                              //队列中的消息个数，主要用来判断队列空还是满
};
 
//使用的时候给出稍大的CThreadQueue初始化参数，可以减少进入内核态的操作。
CThreadQueue queue;
void *
produce (void *arg)
{
  int i = 0;
  pthread_detach (pthread_self ());
  while (i++ < 100)
  {
      queue.putq ((void *) i);
  }
}
 
void *
consume (void *arg)
{
  int data;
  while (1)
  {
      data = (int) (queue.getq ());
      printf ("data=%d\n", data);
  }
}
 
int
main ()
{
  pthread_t pid;
  int i = 0;
 
  while (i++ < 3)
      pthread_create (&pid, 0, produce, 0);
  i = 0;
  while (i++ < 3)
      pthread_create (&pid, 0, consume, 0);
  sleep (30);
  return 0;
}

还是delete

dutor — Sat, 22 Aug 2009 02:35:10 +0000

以前写过一篇关于delete的日志，那里提到的只是一个实验而已，我想正常人不会犯那么弱智的错误吧。但接下来的这个问题就不得不加倍留心了。直接看代码：

#include 
#include 
using namespace std;
 
class M
{
    public:
        M(){}
        ~M()
        {
            cout<<"M destructed..."<<endl;
        }
    private:
        int i;
};
class B
{
    public:
        B(){}
        //! virtual ~B(){}
        ~B(){}
};
class D: public B
{
    public:
        D(){}
        ~D(){}
    private:
        M m;
};
 
int
main()
{
    B * pb = new D;
    delete pb;
    return 0;
}

表明看来似乎合情合理，由于C++的多态特性，允许我们将一个子类地址赋给父类型的指针pb，释放对象时理所当然的对pb进行delete。但，在程序运行时，并没有输出M destructed…，即D::m的析构函数没有被调用，而m的析构函数是需要D::~D()来调用的，所以子类D的析构函数也没有被调用。这是很容易理解的，因为父类的析构函数不是virtual的。由此，我们得出结论，用来继承的父类的析构函数总应该是virtual的，除非你确定它绝对不会被用于多态。关于这一点，《Effective C++》里面已经讲到了。

除了上面的问题，我们还应该关心的是，尽管析构函数没有被调用，那M::i的空间被释放了吗？It’s a question！由于析构函数没有被调用，那么释放M::i的任务就完全落在了delete身上的了，那么delete做到了吗？It’s a very question！这又回到了上一篇日志中所描述的问题上了。我的观点是delete做到了它应该做的事情，它只负责释放当初new申请的空间，即对象本身，至于对象里面是否有动态申请的内存，那就不是delete而是对象析构函数自己的工作了。

pthread_mutex一例

dutor — Fri, 21 Aug 2009 12:11:01 +0000

#include 
#include 
 
using namespace std;
 
pthread_mutex_t mutex; //~ 创建互斥锁mutex
int share = 0; //~ 共享数据
 
//~ 线程入口
void * thread_function(void *arg)
{
	const int N = 1000000;
	for(int i = 0; i < N; ++i)
	{
		//~ 访问共享数据
		pthread_mutex_lock(&mutex);
		share++;
		pthread_mutex_unlock(&mutex);
	}
}
int
main()
{
	pthread_mutex_init(&mutex, NULL); //~ 初始化互斥锁mutex
	pthread_t thread_id;
	void *exit_status;
	pthread_create(&thread_id, NULL, thread_function, NULL); //~ 创建新线程
	for(int i = 0; i < 10; ++i)
	{
		usleep(10000); //~ 延时10ms
		//~ 访问共享数据
		pthread_mutex_lock(&mutex);
		cout<<share<<endl;
		pthread_mutex_unlock(&mutex);
	}
	pthread_join(thread_id, &exit_status); //~ 等待线程结束
	pthread_mutex_destroy(&mutex); //~ 销毁互斥锁
	return 0;
}

用streambuf更改fstream的缓冲区

dutor — Wed, 19 Aug 2009 12:09:54 +0000

源码之前，了无秘密。

//~ demo.cpp
#include 
#include 
#include 
#include 
using namespace std;
//~ 测试代码 :)
int main()
{
	ifstream in("demo.cpp");
	char buffer[4096]="original content in this buffer";
	cout<<buffer<<endl;
	streambuf * ptrbuff = in.rdbuf(); //~ 将streambuf与文件句柄关联
	ptrbuf->pubsetbuf(bufer, 4096); //~ 设置缓冲区，即设置in的缓冲区
	cout<<buffer<<endl; //~ 此时bufer里面的内容还是original content in this buffer
	string str;
	in>>str; //~ 真正要输入时bufer才被填充为in的内容
	cout<<str<<endl;
	cout<<buffer<<endl;
	return 0;
}

另外，还有一个filebuf，用法相近。看了很多C++方面的书，从来没有那本书对I/O流做过详细的介绍。C里面有setbuf可以修改缓冲区，但我在fstream里面却没看到这么个setbuf，rdbuf倒是有一个，它返回streambuf类型的指针。搜索streambuf的用法，无果，MSDN里面看到streambuf有一个setbuf的成员，甚喜。编译器说，setbuf是私有的，再看MSDN，还有一个pubsetbuf，哟西！

Dutor » 之语言特性

const在C和C++中的区别

[C/C++]volatile

volatile

volatile vs. const

qsort

struct/class关键字何时是必须的？

[STL]函数对象/仿函数

什么是函数对象

函数对象的分类

Predicates

算术运算函数对象

绑定Binders

Negaters

Member Function Adapters

[C++]exit & abort & 析构 & 异常

进程之死

程序死亡方式对对象析构的影响

exit做了什么

使用异常

[C++]覆盖std内的名字

Visual Studio中的Functional

更新

[C++]优先级队列priority_queque

一个关于大小端的问题

[C++]虚 静态函数

[Tricks]C++成员函数和静态变量

char & * & []

内存泄漏小陷阱

关于内联的疑问

Go！！！

C++模板为什么不能分离式编译

sizeof只是个运算符

一段小程序

还是虚存

fstream二进制形式读取文件

线程消息队列

还是delete

pthread_mutex一例

用streambuf更改fstream的缓冲区

[C++]虚静态函数