wetwoo的小窝

简单的INI类

wetwoo的小窝 — Wed, 15 Apr 2009 06:04:00 GMT

#ifndef _BASIC_INI_H_
#define _BASIC_INI_H_

#include <string>
#include <vector>
#include <utility>
#include <iostream>
#include <fstream>
#include <sstream>

//
// ini文件操作
//
//@remark
//
// ini文件格式如下：
//
// [section_11]
//   key_1=value_1
//   key_2=value_2
//
//   key_n=value_n
//
// [section_n]
//
// 注意：
// 1.大小写敏感
// 2.以“;”开头的行均认为是注释。
// 3.若解析[section]出错，则其下的所有key_value对均认为属于上一个[section]
// 若解析第一个[section]出错，则忽略其下的所有key_value对。
//
class Ini
{
public:
    typedef size_t                                size_type;

    typedef std::pair<std::string, std::string>    key_val;

    typedef std::vector<key_val>                kv_vec;
    typedef kv_vec::iterator                    key_val_iter;
    typedef kv_vec::const_iterator                key_val_citer;

    typedef std::pair<std::string, kv_vec>        section;

public:
    Ini() {}
    Ini(std::istream &stream);
    Ini(const std::string &path);

    //
    // 加载/保存
    //
    bool LoadFromFile(const std::string &path);
    void LoadFromText(const std::string &text);
    void LoadFromStream(std::istream &stream);
    bool SaveToFile(const std::string &path);
    void SaveToStream(std::ostream &stream);

    //
    // 获取指定section下指定key对应的value
    //
    bool GetValue(const std::string &sec, const std::string &key, std::string &val) const;
    bool GetValue(const std::string &sec, const std::string &key, bool &val) const;
    bool GetValue(const std::string &sec, const std::string &key, short &val) const;
    bool GetValue(const std::string &sec, const std::string &key, unsigned short &val) const;
    bool GetValue(const std::string &sec, const std::string &key, int &val) const;
    bool GetValue(const std::string &sec, const std::string &key, unsigned int &val) const;
    bool GetValue(const std::string &sec, const std::string &key, long &val) const;
    bool GetValue(const std::string &sec, const std::string &key, unsigned long &val) const;
    bool GetValue(const std::string &sec, const std::string &key, float &val) const;
    bool GetValue(const std::string &sec, const std::string &key, double &val) const;
    bool GetValue(const std::string &sec, const std::string &key, long double &val) const;

    //
    // 枚举section
    //
    size_type GetSectionSize() const
    { return _sv.size();    }
    section& operator[](size_type pos)
    { return _sv[pos]; }
    const section& operator[](size_type pos) const
    { return _sv[pos]; }

    //
    // 获取section
    //
    section* GetSection(const std::string &sec);
    const section* GetSection(const std::string &sec) const;

    //
    // 添加section
    //
    void append_section(const section &sec)
    { _sv.push_back(sec); }

private:
    typedef std::vector<section> sec_vec;

private:
    sec_vec _sv;
};
//////////////////////////////////////////////////////////////////////////
inline Ini::Ini(const std::string &path)
{
    LoadFromFile(path);
}

inline Ini::Ini(std::istream &stream)
{
    LoadFromStream(stream);
}

inline bool Ini::LoadFromFile(const std::string &path)
{
    std::ifstream fin(path.c_str());
    if(!fin)
        return false;

    LoadFromStream(fin);

    return true;
}

inline void Ini::LoadFromText(const std::string &text)
{
    LoadFromStream(std::istringstream(text));
}

inline void Ini::LoadFromStream(std::istream &stream)
{
    using namespace std;

    while(stream)
    {
        string line;
        getline(stream, line);
        if(line.empty())
            continue;

        istringstream sl(line);

        ws(sl);

        if(sl.peek() == ';')
        {
        }
        else if(sl.peek() == '[')
        {
            sl.ignore();

            section sec;
            getline(sl, sec.first, ']');
            if(!sl.eof())
                _sv.push_back(sec);
        }
        else
        {
            if(!_sv.empty())
            {
                key_val kv;
                getline(sl, kv.first, '=');
                if(!sl.eof())
                {
                    getline(sl, kv.second);
                    _sv.back().second.push_back(kv);
                }
            }
        }
    }
}

inline bool Ini::SaveToFile(const std::string &path)
{
    using namespace std;

    ofstream fout(path.c_str());
    if(!fout)
        return false;

    SaveToStream(fout);

    return true;
}

inline void Ini::SaveToStream(std::ostream &stream)
{
    for(size_type i = 0; i < _sv.size(); ++i)
    {
        stream<<'['<<_sv[i].first<<']'<<std::endl;

        key_val_citer it;
        key_val_citer ed = _sv[i].second.end();
        for(it = _sv[i].second.begin(); it != ed; ++it)
            stream<<it->first<<'='<<it->second<<std::endl;
    }
}

inline bool Ini::GetValue(const std::string &sec, const std::string &key, std::string &val) const
{
    for(size_type i = 0; i < _sv.size(); ++i)
    {
        if(sec != _sv[i].first)
            continue;

        key_val_citer it;
        key_val_citer ed = _sv[i].second.end();
        for(it = _sv[i].second.begin(); it != ed; ++it)
        {
            if(it->first == key)
            {
                val = it->second;
                return true;
            }
        }
    }

    return false;
}

inline Ini::section* Ini::GetSection(const std::string &sec)
{
    for(size_type i = 0; i < _sv.size(); ++i)
    {
        if(sec == _sv[i].first)
            return &_sv[i];
    }

    return NULL;
}

inline const Ini::section* Ini::GetSection(const std::string &sec) const
{
    for(size_type i = 0; i < _sv.size(); ++i)
    {
        if(sec == _sv[i].first)
            return &_sv[i];
    }

    return NULL;
}

#define INI_GETVALUE_IMPL(TYPE)
    inline bool Ini::GetValue(const std::string &sec, const std::string &key, TYPE &val) const
    {
        using namespace std;

        string str;
        if(!GetValue(sec, key, str))
            return false;

        istringstream ss(str);
        return !!(ss>>val);
    }

INI_GETVALUE_IMPL(bool)
INI_GETVALUE_IMPL(short)
INI_GETVALUE_IMPL(unsigned short)
INI_GETVALUE_IMPL(int)
INI_GETVALUE_IMPL(unsigned int)
INI_GETVALUE_IMPL(long)
INI_GETVALUE_IMPL(unsigned long)
INI_GETVALUE_IMPL(float)
INI_GETVALUE_IMPL(double)
INI_GETVALUE_IMPL(long double)

#endif

关于RamDisk

wetwoo的小窝 — Wed, 01 Apr 2009 05:08:00 GMT

一　创建虚拟磁盘设备
IoCreateDevice(...,
                FILE_DEVICE_VIRTUAL_DISK,        // 虚拟磁盘设备
                (FILE_DEVICE_SECURE_OPEN),
                FALSE,                                                  // This isn't an exclusive device
                ...);

二　分配/加载映像
　　注：分配映像内存时，需要对映射内存进行格式化（FAT16/FAT32/NTFS）。

三　创建符号链接
　　IoCreateSymbolicLink(L“\\DosDevices\\X:“,    // 符号链接名（A~Z）
                                            L“\\Device\\Xxxxx“);    // 设备名

四　实现如下分发函数
　　1.IRP_MJ_CREATE/IRP_MJ_READ/IRP_MJ_WRITE/IRP_MJ_CLOSE
　　由FS调用，用于打开/关闭设备、读写设备。
　　注：读写时不需要考虑映像格式。

　　2.IRP_MJ_DEVICE_CONTROL
　　由FS调用，用于查询设备。需要响应：IOCTL_DISK_GET_PARTITION_INFO、IOCTL_DISK_GET_DRIVE_GEOMETRY、IOCTL_DISK_CHECK_VERIFY、IOCTL_DISK_IS_WRITABLE。

　　3.IRP_MJ_SYSTEM_CONTROL/IRP_MJ_PNP/IRP_MJ_POWER　
　　仅传递给下层驱动处理。

参考：
http://support.microsoft.com/kb/257405

关于闰年

wetwoo的小窝 — Thu, 26 Feb 2009 04:49:00 GMT

地球每天自转一周，需要24小时，换算成秒合每天86400秒。地球绕日公转一周，需要365天5小时48分46秒。因此，现行的立法是过三个365天的平年，再过一个366天的闰年。四年一闰。 5小时48分46秒等于0.2422天，并不足1/4天，所以需要每100年减一天，即“百年一免闰”。但如此免闰，又产生了微略的多余，于是每隔四百年，不实行“百年一免闰”，即“四百年一复闰”。如此算下来，四百年置闰的结果，积亏光阴2小时53分20秒。平均每年亏26秒。积3200年，累亏83200秒，实行一免闰，弥补86400秒，又多了3200秒。恰好是平均每年多一秒。
只有经过86400年（合27个3200年），再实行一复闰。至此方无一秒之盈亏，可以称之为“天衣无缝年”。八万六千四百年，在人类历史的概念中是漫长的，但在宇宙时间的长河中则只是短暂的一刻钟。最后去繁就简，一年的换算可以归结为：
一天二十四小时，八万六千四百秒。
天衣无缝一循环，八万六千四百年。

关于Windows下进程当前目录问题

wetwoo的小窝 — Thu, 19 Feb 2009 07:22:00 GMT

很久以前看到过这个问题，但没有怎么注意，今天还真碰到了，真粗心啊！

From MSDN.GetCurrentDirectory Function [Files]

Each process has a single current directory that consists of two parts:
*A disk designator that is either a drive letter followed by a colon, or a server name followed by a share name (\\servername\sharename)
*A directory on the disk designator

一个进程对于每个盘符（C:、D:等）都有一个当前路径，这样就会产生一个问题，例如：
SetCurrentDirectoryA("C:\\Windows\\System32");
SetCurrentDirectoryA("D:\\Windows\\System32");

1.SetCurrentDirectoryA("C:");
此时，通过GetCurrentDirectoryA获取的当前目录是C:\Windows\System32而不是C:，因为最后一条语句的意思是使用C:盘符的当前路径作为当前的当前路径。

2.SetCurrentDirectoryA("C:\\")、SetCurrentDirectoryA("\\")和SetCurrentDirectoryA("..\\")
第一个和第二个的调用结果是一样的，最后当前的当前路径都是C:\\
第三个当前的当前路径是：C:\Windows

做什么事一定要细心细心~~~~

ReadDirectoryChangesW与CloseHandle的问题

wetwoo的小窝 — Thu, 05 Feb 2009 09:13:00 GMT

unsigned __stdcall MonitorFileChangeThread(void *pVoid);

int main(int argc, char* argv[])
{

    HANDLE hDirectory = CreateFile("E:\\", GENERIC_READ,
        FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL,
        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OVERLAPPED, NULL);

    HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, MonitorFileChangeThread, (void*)hDirectory, 0, NULL);

    Sleep(5*1000);

    CloseHandle(hDirectory);
    WaitForSingleObject(hThread, INFINITE);

    return 0;
}

unsigned __stdcall MonitorFileChangeThread(void *pVoid)
{
#define BUF_SIZE    64*1024

    DWORD size;
    char buf[BUF_SIZE];
    HANDLE hDirectory = (HANDLE)pVoid;

    while(1)
    {
        if(!ReadDirectoryChangesW(hDirectory, buf, BUF_SIZE, TRUE,
            FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_SIZE,
            &size, NULL, NULL) || GetLastError() == ERROR_INVALID_HANDLE)
        {
            break;
        }

        PFILE_NOTIFY_INFORMATION pFNI = (PFILE_NOTIFY_INFORMATION)buf;

        do
        {
            pFNI = (PFILE_NOTIFY_INFORMATION)pFNI->NextEntryOffset;
        }
        while(pFNI != 0);
    }

    return 0;
}

注意：
1.若不添加FILE_FLAG_OVERLAPPED标志，CloseHandle不会立即返回，直到ReadDirectoryChangesW有通知或出错返回为止。
看看WRK找找原因先~~~~~~
2.CreateFile("E:", ...)表示监视E:盘符的当前路径，CreateFile("E:\\", ...)表示监视E:盘符根目录

5.2　使用this->

wetwoo的小窝 — Tue, 03 Feb 2009 11:20:00 GMT

对于具有基类的类模板，自身使用名称x并不一定等同于this->x。即使该x是从基类继承获得的，也是如此，例如：
template <typename T>
class Base
{
public:
    void exit();
};

template <typename T>
class Derived : Base<T>
{
public:
    void foo()
    {
        exit();    //调用外部的exit()或者出现错误
    }
};
　　在这个例子中，在foo()内部决定要调用哪一个exit()时，并不会考虑基类Base中定义的exit()。因此，你如果不是获得一个错误，就是调用了另一个exit()。
　　现在建议你记住一条规则：对于那些在基类中声明，并且依赖于模板参数的符号（函数或者变量等），你应该在它们前面使用this->或者Base<T>::。如果希望完全避免不确定性，你可以（使用诸如this->和Base<T>::等）限定（模板中）所有的成员访问。

5.1　关键字typename

wetwoo的小窝 — Tue, 03 Feb 2009 11:11:00 GMT

.template构造
template <int N>
void PrintBitset(bitset<N> const &bs)
{
cout<<bs.template to_string<char, char_traits<char>, allocator<char> >();
}
　　只有当该前面存在于依赖于模板参数的对象时，我们才需要在模板内部使用.template标记（->template与此类似），而且这些标记也只能在模板中才能使用。

4.2　非类型的函数模板参数

wetwoo的小窝 — Tue, 03 Feb 2009 09:46:00 GMT

template<typename T, int VAL>
T addValue(T const &x)
{
    return x + VAL;
}

transform(source.begin(), source.end(),
    dest.begin(),
    (int(*)(int const&))addValue<int, 5>);

　　这个例子有一个问题：addValue<int, 5>是一个函数模板实例，而函数模板实例通常被看成是用来命名一组重载函数的集合（即使该组只有一个函数）。然而，根据现今的标准，重载函数的集合并不能被用于模板参数的演绎。于是，在上面的例子中必须对函数模板的强制类型转换为具体的类型。
　　现在有一个提议，建议C++标准解决这个问题，从而在这种情况下不需要进行强制类型转换（细节请见[CoreIssue115]）。如果这个提议被通过的话，那么只有在考虑可移植性的情况下，才需要使用这种强制类型转换。

4.3　非类型模板参数的限制

wetwoo的小窝 — Tue, 03 Feb 2009 09:29:00 GMT

非类型模板参数可以是常整数（包括枚举值）或者指向外部链接对象的指针。浮点数和类对象（class-type）是不允许作为非类型模板参数的。之所以不能使用浮点数（包括简单的常量浮点表达式）作为模板实参是有历史原因的。然而，该特性的实现并不存在很大的技术障碍；因此，将来的C++版本可能会支持这个特性。
　　下面是指向外部链接对象的指针作为非类型模板参数的示例代码：

template<char const *pName>
class MyClass
{
//...
};

extern char const s[] = "外部链接对象";

MyClass<s> x; //OK

全局字符数组s由“外部链接对象”初始化，是一个外部链接对象。

valarray的用法小记

wetwoo的小窝 — Tue, 03 Feb 2009 04:28:00 GMT

[Header File]

* valarray Class
    数值数组

* slice and gslice Class
    对valarray进行分片

* slice_array, gslice_array, mask_array, and indirect_array Class
    内部的辅助类，用于存储临时数据。这些类仅由valarray的特定操作间接产生，无法直接使用。

[Valarray Operations]

    若组合的valarray的元素个数不同，则结果是未定义的。

[Valarray Subsets]

    va[slice(2, 4, 3)] // four elements with distance 3 starting from index 2
    va[va>7] 　　　// all elements with a value greater than 7

    因为避免了“临时值”，所以只有保证目标子集和源子集的元素必须是不同的时，valarray的任何操作才保证正确。

    有四种方法来定义valarray的子集：
    1.Slices
    2.General slices
    3.Masked subsets
    4.Indirect subsets

[Valarray Subset Problems]

    在开始介绍子集之前，不得不谈一个通常的问题。valarray的子集的处理设计的并不好。你可以很容易的创建子集，但是你不能很容易的合并子集。不幸的是，你总是需要对valarray进行显示的类型转换。这是因为C++标准库并没有为valarray的子集提供与valarray相同的操作符。
    例如，对于将两个子集相乘并赋值给第三个子集，你不能这样写：
    // ERROR : conversions missing
    va[slice(0, 4, 3)] = va[slice(1, 4, 3)] * va[slice(2, 4, 3)];
相反，你不得不使用新的类型转换编码：
    va[slice(0, 4, 3)] =
        static_cast >(va[slice(1, 4, 3)] *
        static_cast >(va[slice(2, 4, 3)];
或者使用老的类型转换：
    va[slice(0, 4, 3)] =
        valarray(va[slice(1, 4, 3)]) *
        valarray(va[slice(2, 4, 3)]);
或者使用模板函数：
    template inline
    valarray VA(const T &valarray_subset)
    {
        return valarray(valarray_subset);
    }
    va[slice(0, 4, 3)] = VA(va[slice(1, 4, 3)]) * VA(va[slice(2, 4, 3)];
然而上面存在着性能损失。你也可以使用简单的类型定义：
    typedef valarray VAD;
    va[slice(0, 4, 3)] = VAD(va[slice(1, 4, 3)]) * VAD(va[slice(2, 4, 3)];

[Slices]

    slice定义了一个索引集合，具有三个属性：
    1.开始索引
    2.元素个数
    3.元素之间的距离(步长)
    注意：索引集合中索引的有效性由使用者保证。

    步长可以为负数。例如：
    slice(9, 5, -2)
指定的索引为：
    9 7 5 3 1

    若valarray是常量，则由slice指定的子集为一个新的valarray，否则该子集为原始valarray的引用(该功能由辅助类slice_array提供)。

[General Slices]

    gslices可以处理多维数组的子集，具有三个属性：
    1.开始索引
    2.维度数组(高维到低维)
    3.对应维度的元素之间的距离(步长)
    与slice的使用方法基本类似。

[Masked Subsets]

    Mask arrays提供了另外一种定义valarray子集的方法。你可以通过对valarray使用布尔操作产生mask array，mask array中的每个元素代表相应的valarray元素是否满足布尔条件。

[Indirect Subsets]

    Indirect subsets提供了第四种定义valarray子集的方法(valarray[索引valarray])。

注：摘自《The C++ Standard Library——A Tutorial and Reference》

LCS...

wetwoo的小窝 — Fri, 23 Jan 2009 03:56:00 GMT

/*******************************************************************************
已知：序列X[1...m]和Y[1...n]
　　　LCS(Xi, Yj)表示序列X[1...i]和Y[1...j]的最长公共子序列则：
                   ┌0 i == 0 || j == 0
LCS(Xi, Yj)┼LCS(Xi-1, Yj-1) + 1 X[i] == Y[j]
                   └max(LCS(Xi, Yj-1), LCS(Xi-1, Yj)) X[i] != Y[j]
*******************************************************************************/

int LCS(const string &X, const string &Y)
{
    if(X.size() == 0 || Y.size() == 0)
        return 0;

    vector yLine(Y.size());
    for(int i = 0; i < (int)X.size(); ++i)
   {
        int xy_1 = 0, x_1y_1 = 0;
        for(int j = 0; j < (int)Y.size(); ++j)
       {
            int x_1y = yLine[j];
            if(X[i] == Y[j])
            {
                 yLine[j] = x_1y_1 + 1;
            }
            else
            {
                 yLine[j] = (x_1y > xy_1 ? x_1y : xy_1);
            }
            xy_1 = yLine[j];
            x_1y_1 = x_1y;
        }
    }

    return yLine.back();
}

关于控制台重定向

wetwoo的小窝 — Thu, 22 Jan 2009 05:35:00 GMT

一。控制台重定向格式

program command line [redirect-command]
redirect-command格式如下：
[1] | 2>&1 | &2| other
其中：
1.>左边的1和2分别代表标准输出和标准错误输出
2.>右边的&1和&2分别代表标准输出和标准错误输出
3.other可以为文件路径及其类似的东西

二。示例

1.重定向标准输出至文件
ping www.g.cn >stdout.txt

2.重定向标准错误输出至文件
del xxx.xxx 2>stderr.txt

3.重定向标准输出和标准错误输出至文件
ping www.g.cn 2>stdout.txt 2>&1

New Vectored Exception Handling in Windows XP

wetwoo的小窝 — Fri, 24 Oct 2008 03:23:00 GMT

http://msdn.microsoft.com/msdnmag/issues/01/09/hood

Isolated Applications and Side-by-side Assemblies

wetwoo的小窝 — Thu, 23 Oct 2008 11:06:00 GMT

http://msdn2.microsoft.com/en-us/library/aa375193.aspx

Compiler Security Checks In Depth

wetwoo的小窝 — Wed, 22 Oct 2008 11:31:00 GMT

http://msdn.microsoft.com/en-us/library/aa290051(VS.71).aspx

Application Software Considerations for NUMA-Based Systems

wetwoo的小窝 — Wed, 22 Oct 2008 09:49:00 GMT

http://www.microsoft.com/whdc/system/platform/server/datacenter/numa_isv.mspx
http://msdn.microsoft.com/en-us/library/aa363804.aspx

Best Practices for WOW64

wetwoo的小窝 — Wed, 22 Oct 2008 08:59:00 GMT

http://www.microsoft.com/whdc/system/platform/64bit/WoW64_bestprac.mspx

For more details about DEP, read the Microsoft white paper, "03_CIF_Memory_Protection.DOC"

wetwoo的小窝 — Wed, 22 Oct 2008 08:02:00 GMT

http://go.microsoft.com/fwlink/?LinkId=28022

Wait Chain Traversal

wetwoo的小窝 — Tue, 21 Oct 2008 11:43:00 GMT

http://msdn.microsoft.com/en-us/library/ms681622(VS.85).aspx

Condition VariablesCondition Variables

wetwoo的小窝 — Tue, 21 Oct 2008 04:30:00 GMT

Condition variables are synchronization primitives that enable threads to wait until a particular condition occurs. Condition variables are user-mode objects that cannot be shared across processes.

Condition variables enable threads to atomically release a lock and enter the sleeping state. They can be used with critical sections or slim reader/writer (SRW) locks. Condition variables support operations that "wake one" or "wake all" waiting threads. After a thread is woken, it re-acquires the lock it released when the thread entered the sleeping state.

The following pseudocode demonstrates the typical usage pattern of condition variables.

CRITICAL_SECTION CritSection;
CONDITION_VARIABLE ConditionVar;

void PerformOperationOnSharedData()
{
EnterCriticalSection(&CritSection);

// Wait until the predicate is TRUE

while( TestPredicate() == FALSE )
{
SleepConditionVariableCS(&ConditionVar, &CritSection, INFINITE);
}

// The data can be changed safely because we own the critical
// section and the predicate is TRUE

ChangeSharedData();

LeaveCriticalSection(&CritSection);

// If necessary, signal the condition variable by calling
// WakeConditionVariable or WakeAllConditionVariable so other
// threads can wake
}

For example, in an implementation of a reader/writer lock, the TestPredicate function would verify that the current lock request is compatible with the existing owners. If it is, acquire the lock; otherwise, sleep. For a more detailed example, see Using Condition Variables.

Condition variables are subject to spurious wakeups (those not associated with an explicit wake) and stolen wakeups (another thread manages to run before the woken thread). Therefore, you should recheck a predicate (typically in a while loop) after a sleep operation returns.

You can wake other threads using WakeConditionVariable or WakeAllConditionVariable either inside or outside the lock associated with the condition variable. It is usually better to release the lock before waking other threads to reduce the number of context switches.

It is often convenient to use more than one condition variable with the same lock. For example, an implementation of a reader/writer lock might use a single critical section but separate condition variables for readers and writers.

Slim Reader/Writer (SRW) Locks

wetwoo的小窝 — Tue, 21 Oct 2008 04:19:00 GMT

Slim reader/writer (SRW) locks enable the threads of a single process to access shared resources; they are optimized for speed and occupy very little memory.

Reader threads read data from a shared resource whereas writer threads write data to a shared resource. When multiple threads are reading and writing using a shared resource, exclusive locks such as a critical section or mutex can become a bottleneck if the reader threads run continuously but write operations are rare.

SRW locks provide two modes in which threads can access a shared resource:

Shared mode grants shared read-only access to multiple reader threads, which enables them to read data from the shared resource concurrently. If read operations exceed write operations, this concurrency increases performance and throughput compared to critical sections.
Exclusive mode grants read/write access to one writer thread at a time. When the lock has been acquired in exclusive mode, no other thread can access the shared resource until the writer releases the lock.

A single SRW lock can be acquired in either mode; reader threads can acquire it in shared mode whereas writer threads can acquire it in exclusive mode. There is no guarantee about the order in which threads that request ownership will be granted ownership; SRW locks are neither fair nor FIFO.

An SRW lock is the size of a pointer. The advantage is that it is fast to update the lock state. The disadvantage is that very little state information can be stored, so SRW locks cannot be acquired recursively. In addition, a thread that owns an SRW lock in shared mode cannot upgrade its ownership of the lock to exclusive mode.

Boot Configuration Data in Windows Vista

wetwoo的小窝 — Mon, 20 Oct 2008 12:35:00 GMT

http://www.microsoft.com/whdc/system/platform/firmware/bcd.mspx

I/O Prioritization in Windows Vista

wetwoo的小窝 — Mon, 20 Oct 2008 11:51:00 GMT

http://www.microsoft.com/whdc/driver/priorityio.mspx

Inside Windows NT High Resolution Timers Mark Russinovich

wetwoo的小窝 — Mon, 20 Oct 2008 11:03:00 GMT

http://technet.microsoft.com/zh-cn/sysinternals/bb897569(en-us).aspx

Windows Support for Hyper-Threading Technology

wetwoo的小窝 — Mon, 20 Oct 2008 11:01:00 GMT

http://www.microsoft.com/whdc/system/sysinternals/ht-windows.mspx

Multimedia Class Scheduler Service

wetwoo的小窝 — Mon, 20 Oct 2008 10:30:00 GMT

http://msdn.microsoft.com/en-us/library/ms684247.aspx

Thread Ordering Service

wetwoo的小窝 — Mon, 20 Oct 2008 10:29:00 GMT

http://msdn.microsoft.com/en-us/library/ms686752.aspx

原来还有这些函数啊

wetwoo的小窝 — Thu, 04 Sep 2008 10:11:00 GMT

div() Quotient and remainder of int division
ldiv() Quotient and remainder of long division

几个浮点函数

wetwoo的小窝 — Thu, 04 Sep 2008 10:06:00 GMT

frexp() Converts floating-point value to fractional and integral components
ldexp() Multiplies floating-point value by integral power of two
modf() Extracts signed integral and fractional values from floating-point value

For an example, see Obtaining a File Name From a File Handle

wetwoo的小窝 — Thu, 14 Aug 2008 08:28:00 GMT

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <string.h>
#include <psapi.h>
#include <strsafe.h>

#define BUFSIZE 512

BOOL GetFileNameFromHandle(HANDLE hFile) 
{
  BOOL bSuccess = FALSE;
  TCHAR pszFilename[MAX_PATH+1];
  HANDLE hFileMap;

  // Get the file size.
  DWORD dwFileSizeHi = 0;
  DWORD dwFileSizeLo = GetFileSize(hFile, &dwFileSizeHi); 

  if( dwFileSizeLo == 0 && dwFileSizeHi == 0 )
  {
     printf("Cannot map a file with a length of zero.\n");
     return FALSE;
  }

  // Create a file mapping object.
  hFileMap = CreateFileMapping(hFile, 
                    NULL, 
                    PAGE_READONLY,
                    0, 
                    MAX_PATH,
                    NULL);

  if (hFileMap) 
  {
    // Create a file mapping to get the file name.
    void* pMem = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);

    if (pMem) 
    {
      if (GetMappedFileName (GetCurrentProcess(), 
                             pMem, 
                             pszFilename,
                             MAX_PATH)) 
      {

        // Translate path with device name to drive letters.
        TCHAR szTemp[BUFSIZE];
        szTemp[0] = '\0';

        if (GetLogicalDriveStrings(BUFSIZE-1, szTemp)) 
        {
          TCHAR szName[MAX_PATH];
          TCHAR szDrive[3] = TEXT(" :");
          BOOL bFound = FALSE;
          TCHAR* p = szTemp;

          do 
          {
            // Copy the drive letter to the template string
            *szDrive = *p;

            // Look up each device name
            if (QueryDosDevice(szDrive, szName, BUFSIZE))
            {
              UINT uNameLen = _tcslen(szName);

              if (uNameLen < MAX_PATH) 
              {
                bFound = _tcsnicmp(pszFilename, szName, 
                    uNameLen) == 0;

                if (bFound) 
                {
                  // Reconstruct pszFilename using szTempFile
                  // Replace device path with DOS path
                  TCHAR szTempFile[MAX_PATH];
                  StringCchPrintf(szTempFile,
                            MAX_PATH,
                            TEXT("%s%s"),
                            szDrive,
                            pszFilename+uNameLen);
                  StringCchCopyN(pszFilename, MAX_PATH+1, szTempFile, _tcslen(szTempFile));
                }
              }
            }

            // Go to the next NULL character.
            while (*p++);
          } while (!bFound && *p); // end of string
        }
      }
      bSuccess = TRUE;
      UnmapViewOfFile(pMem);
    } 

    CloseHandle(hFileMap);
  }
  _tprintf(TEXT("File name is %s\n"), pszFilename);
  return(bSuccess);
}

一个图片检索的测试程序

wetwoo的小窝 — Fri, 25 Jul 2008 03:13:00 GMT

一个图片检索的测试程序
下载地址：http://blog.vckbase.com/Files/wetwoo/IQSysPrj.rar

原来如此2

wetwoo的小窝 — Fri, 12 Oct 2007 02:07:00 GMT

/* const int ARRAY_LEN(ar); */
#ifdef __cplusplus
    #if defined(_MSC_VER) && (_MSC_VER <= 1200)
      #define ARRAY_LEN(ar) (SIZEOF(ar) / SIZEOF(0[ar]))
    #else
      template<int N>
        struct bytes_struct_of_ARRAY_LEN
       {
          char b[N];
       };
      template<typename T, int N>
          bytes_struct_of_ARRAY_LEN<N> get_bytes_struct_of_ARRAY_LEN(T (&) [N]);
      #define ARRAY_LEN(x) SIZEOF(get_bytes_struct_of_ARRAY_LEN(x))
   #endif
#else
   #define ARRAY_LEN(ar)  (SIZEOF(ar) / SIZEOF(0[ar]))
#endif
注：
1.0[ar]仅为了避免ar为vector类型时导致编译错误
2.红色部分仅为了推导出常数N，非数组类型将会出错误

原来如此

wetwoo的小窝 — Fri, 12 Oct 2007 01:07:00 GMT

问题：为什么如此使用
#if (_MSC_VER <= 1200)
　#define for if(0) ((void)0); else for
#endif
解答：
因为vc6不符合C++标准，在对于for( 类型变量; ; ) 中的变量作用域溢出到for外。

奇怪的问题

wetwoo的小窝 — Wed, 06 Jun 2007 03:54:00 GMT

昨天看到一个“古老的智力题”，有意思，贴出来大家瞅瞅：
奇怪的问题
请回答下面10个问题，你的回答应保证每题惟有你的选择是正确的。
(1)第一个答案是b的问题是哪一个？
(a)2    (b)3    (c)4    (d)5    (e)6

(2)恰好有两个连续问题的答案是一样的，它们是：
(a)2,3    (b)3,4    (c)4,5    (d)5,6    (e)6,7

(3)本问题答案和哪一个问题的答案相同？
(a)1    (b)2    (c)4    (d)7    (e)6

(4)答案是a的问题的个数是：
(a)0    (b)1    (c)2    (d)3    (e)4

(5)本问题答案和哪一个问题的答案相同？
(a)10    (b)9    (c)8    (d)7    (e)6

(6)答案是a的问题的个数和答案是什么的问题的个数相同？
(a)b    (b)c    (c)d    (d)e    (e)以上都不是

(7)按照字母顺序，本问题的答案和下一个问题的答案相差几个字母？
(a)4    (b)3    (c)2    (d)1    (e)0(注：a和b相差一个字母)

(8)答案是元单字母的问题的个数是：
(a)2    (b)3    (c)4    (d)5    (e)6(注：a和e是元音字母)

(9)答案是辅字母的问题的个数是：
(a)一个质数    (b)一个阶乘数    (c)一个平方数    (d)一个立方数    (e)5的倍数

(10)本问题的答案是：
(a)a    (b)b    (c)c    (d)d    (e)e