daeees的专栏

#ifndef _KOK_MAXHEEP_H_#define _KOK_MAXHEEP_H_#pragma once#include "Alloc.h"namespace KOK{    template     class CMaxHeep    {        template         struct CMaxHeepNode        {            typed

 在STL中，copy函数被多次重载过，当然是为了效率： 而在针对内建类型的特化版本会采用memove(), 而memove会将整个输入区别先copy下来，再进行copy,这样就不会有重叠区间copy覆盖的问题，而其他的版本的copy则要小心这个问题。

STL 中的allocate调用了::operator new() -----此函数不会调用construct；同理deallocate。 而new 或者 delete则编译器会自动算出size_t 和 void *p并传给::operator new及::operator delete,然后调用construct及deconstruct 一句话::operator new/::o

#ifndef _KOK_AVLTREE_H_#define _KOK_AVLTREE_H_#pragma once#include "Alloc.h"#include "Utility.h"namespace KOK{    template     class CAVLTree    {        enum __Balance { L = 1, B = 0, R = -1, H =

“typedef”，大家都很熟悉，它是用来为内建类型或用户自定义类型引入助记符号的。但是有很多人（甚至是有经验的程序员）仍然将typedef理解为“宏”，或者至少按照“宏”的语法和语义去推断typedef的相关规则。           下面就是这个例子可以给这些人敲一个警钟（还是“悬崖勒马”吧）：           typedef   int   *pitype;           exte

<br />try to use gcc -lstdc -o test test.cpp

<br />可见,同步/异步与阻塞/非阻塞是两组不同的概念,它们可以共存组合,也可以参见这里:http://www.ibm.com/developerworks/cn/linux/l-async/   同步和异步:上面提到过, 同步和异步仅仅是关于所关注的消息如何通知的机制,而不是处理消息的机制.也就是说,同步的情况下,是由处理消息者自己去等待消息是否被触发,而异步的情况下是由触发机制来通知处理消息者,所以在异步机制中,处理消息者和触发机制之间就需要一个连接的桥梁,在我们举的例子中这个桥梁就是小纸条上面的号

<br /> 直接上例子:<br /> <br />    template <bool> <br />    struct StaticCheck { StaticCheck(...);}; <br />    template <> <br />    struct StaticCheck<false> {}; <br /> <br />    bool f =false;<br />    StaticCheck<f>();<br /> <br />报错: Error 1 error C2971: '

<br />有的时候为了保证一个类的对象必须在堆上被创建, 比如当我们需要手动控制一个对象的生命周期的时候, 这个时候就必须保证这个对象是在堆上创建的, 如何保证呢, 有个小的技巧:<br /> <br />class A <br />{<br />public:<br />    void Close() {delete this; }<br />private:<br />    ~A() { ... };<br />};<br /> <br />int main()<br />{<br />    A

<br />内存映射文件提供了一个统一的内存管理特征，使得应用程序能够通过内存指针象访问动态内存一样对磁盘上的文件进行访问。通过内存映射文件，您可以将磁盘上文件的全部和部分映射为一个视图到进程虚拟地址空间的某个位置。一旦完成了映射视图，对文件内容的访问就如同在该地址区域内直接对指针取值一样简单。这样，向文件中写入数据就可以直接对指针进行赋值，如：<br />*pMem = 23;<br />同样，从文件的某个特定位置读取数据也一样非常的简单：<br />nTokenLen = *pMem;<br />在这个

今天起开始总结一些C++中的Tip, 首先开始的是继承.我们知道在c++中,父类中的私有函数在子类中是不可见, 这的确是正确的. 但是这个却对于virtual的方法无效.如下所示, 尽管在父类中P1,P2是私有的,但是在子类中依然可以重写这2个virtual的方法. 并且可以在子类中扩大重写方法的可见性.下面的代码描述了template design pattern, 定义一个骨架, 并且在子类中将细节的小片方法重写达到动态的目的, 同样也可保证virtual的可见性,将不能被直接访问到. #include

<br />暂时参考我之前博文:<br />STL源码剖析 - 模板类中的友元函数<br />template函数和函数的重载的调用判断<br /> 

<br />今天的内容是const. 有几点不得不说:const是compile-time的,不影响runtime.所以不会影响效率对于传参数中用到const,  在值类型时不需要使用, 因为值类型始终会有个拷贝,所以加了const也没用, 只需要在传指针和引用时使用.在const的对象上只能调用const的成员方法.const会加入方法的重载决议, 所以可以针对const的版本进行重载.int*隐式转const int*允许, 而const int* 隐式转int*不允许const指针仅仅保证无法通过这个

从下面代码可以知道，用reinterpret_cast将一种类型的指针转到另外一种类型的指针是不会出现任何错误的，但是仅仅是编辑器的错误哈哈。另外，注意用引用传参，节省copy 时间么。  // general casetemplateinline Return_Type &force_cast(Argument_Type &rSrc){    return(*reinterpret_

如题，如何用最小的代价来实现同步呢，即无锁编程（主要是使用原子操作替代锁来实现对共享资源的访问保护）,我们来看看下面的代码。首先，我们需要是在这个函数内部对地址x中的值进行位测试并将其对应的位置位。  这里的关键是我们必须先读出*x的值，作位或运算之后，将得到的值对*x赋值。而在多线程环境中，在读出*x后也许有另外的线程对*x进行写操作，这样在给*x赋值的时候就会把对旧的值位或的结果赋给*

#ifndef _KOK_RBTREE_H_#define _KOK_RBTREE_H_#pragma once#include "Alloc.h"#include "Utility.h"namespace KOK{    template     class CRBTree    {        enum __Color { R = 0, B = 1 };        templ

#ifndef _KOK_SMARTPTR_H_#define _KOK_SMARTPTR_H_#pragma once#include #include #include namespace KOK{    template    class CheckAssert    {    protected:        void OnRef(const P& pointer)     

#ifndef _KOK_HASHTABLE_H_#define _KOK_HASHTABLE_H_#pragma once#include "Alloc.h"#include "Assert.h"#include "MemoryPool.h"namespace KOK{            namespace    {        static const int PRIMECOUN

在 type_traits中有个is_Empty函数，用来判断一个class是否是空类 如: struct A {}; sizeof(A) = 1;struct B : public A {int i}; sizeof(B) = 4struct C {int i} sizeof(C) = 4 则if sizeof(C) == sizeof (B)则A为空

struct H {};struct G{    operator H() const { printf("!!!/n"); return H();}};template void ff(T, H) //T不用转换，H 转换一次，共一次。T参数满足--当在其他同名函数中没有这个参数的满足的情况下，范型算是满足（共一次）{    printf("int,T/n");}void ff(in

#ifndef _KOK_MEMORYPOOL_H_#define _KOK_MEMORYPOOL_H_#pragma once#include #include "StaticAssert.h"#include #define NULL 0namespace KOK{    typedef void (*FnDestroy)(void* p);    struct Array

    template     struct StaticCheck { StaticCheck(...);};     template     struct StaticCheck {}; #define STATIC_ASSERT(expr, msg)                                                    /    {       

 template void func(T,U) { printf("T,U/n"); }template void func(T,T) { printf("T,T/n"); }func(int(), int()):即,template function无法偏特化,但是很多时候我们都需要能够有function 偏特化的存在, 这样就只能利用function overlo

#ifndef _ALLOC_H_#define _ALLOC_H_#pragma once#include #include "Assert.h"#ifndef NULL#define NULL 0#endifnamespace KOK{    class __CSimpleAlloc    {    public:        static void* Allocate(size

boost::call_once应用及其实现 以下是一个典型的运用call_once实现一次初始化的例子：Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 #include boost/thread/thread.h

    BOOST的Thread库博大精深，有很多的多线程概念在里面，今天就对其中很多call都用到的interrupt_wait的实现进行解释。首先，在BOOST文档中，有1个不得不看的概念，如下：Predefined Interruption Points The following functions are interruption points, which will throw

 先不多说，来看段代码： struct state_data        {            unsigned shared_count:11,                shared_waiting:11,                exclusive:1,                upgrade:1,                exclusive_wait

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#The__define_GuardGist: 头文件：#define: ___H_. #include: 当forward declaration(for example: class A;) 够用时别再用#include了在没有类定义的情况下(For example, only declare class Foo), 依然可用的有：数据成员是Foo* or Foo&函数的参