一篇很好的介绍C++头文件如何组织和引用的文章：

Headers and Includes: Why and How [By Disch]

    使用GDB的"p variable-name"查看STL容器类，只会显示该容器的一些信息，并不能很友好的显示该容器的内容。使用stl-views.gdb这个脚本可以很好地解决这一问题。下载stl-veiws.gdb文件，将其放到~/目录下，直接将其改名为~/.gdbinit，或者在你已有的.gdbinit文件中用source ~/.stl-views.gdb命令将其包含。这样你就可以用下面的命令显示STL容器类了。

举例：

如果你的C++代码中有定义: set<string> s;
则在GDB中可以使用如下命令查看该set的信息与内容：
pset s - 打印该集合s的定义和大小
pset s char* - 打印该集合s的大小以及该集合的所有元素

摘自：《面向对象分析设计与编程(OOA/OOD/OOP/AOP)》  第二版  吴炜煜 编著  清华大学出版社

    在这里，我们讨论类的两种特殊成员两数——构造函数和析构函数在虚函数机制中的使用。构造函数为对象分配存储空间，使一个对象初始化，而析构函数在该对象生命期完结时做相应的扫尾工作并释放出构造函数分配的内存。那么，这两种函数是否可以声明为虚函数呢?
    构造函数不能是虚函数。这一点可以从两个方而来解释。从概念上来说，虚函数机制只有在应用于地址时才有效，因为地址在编译阶段提供的类型信息不完全。构造函数的功能是为一个对象在内行中分配空间，也就是说，此时该对象的类型已经确定了，编译系统确切的知道应该调用哪—个类的构造函数。不需要也不可能应用动态绑定。从实现上来说，每个对象的VPTR需要构造函数来创始化(当然是由编译系统自动加进去的代码来实现)。在构造函数没有调用之前VPTR没有形成，根本就不可能实现动态绑定。
    那么，当构造函数内部有虚函数时，又会出现什么情况呢?结果是，只有在该类中的虚函数版本被调用。也就是说，此时虚函数机制不起作用了，调用虚函数如同调用—般的成员函数一样。
    构造函数不能是虚函数，那么析构函数呢？我们说，析构函数可以是虚函数，而且应该被声明为虚函数。与一般成员函数相似，析构函数被调用时，对象的构造已经完成，VPTR和VTABLE也已被正确初始化，因此虚析构函数在实现上是可能的。从设计角度来看，析构函数的任务是释放内存，因此它必须确切知道被释放的对象的类型，否则可能破坏有用的数据，产生不可预知的后果。例如，我们用基类指针指向了派生类对象，那么释放内作时，必须是释放派生类对象的存储空间。所以，析构函数经常被声明为虚函数。由于效率上的原因，并不把析构函数缺省为虚函数。但作为一条实践经验、可以给有虚函数的每个基类声明虚析构函数。
    同样的问题是，当析构函数内部有虚函数时，会如何工作呢？与构造函数相同，只有“局部”的版本被调用。但是，行为相同，原因是不一样的。构造函数只能调用“局部”版本，是因为调用时还没有派生类版本的信息。析构函数则是因为派生类版本的信息已经不可靠了。我们知道，析构函数的调用顺序与构造函数相反，是从派生类的析构函数到基类的析构函数。当某个类的析构函数被调用时，其下一级的析构函数已经被调用了，相应的数据也已被丢失，如果再调用虚函数的最后一级的版本，就相当于对一些不可靠的数据进行操作，这是非常危险的。因此，在析构函数中，虚函数机制也是不起作用的。

    另外说明一点，析构函数不能为纯虚函数，但你可以为其定义一个什么都不做的实现(里面是空语句)。

    在Robert Sedgewick所著的Algorithm In C中，把二维数组当成数组的数组为它动态分配内存。

    首先，分配一个指针的数组，然后为每一行分配内存。
函数定义：
    void **malloc2d(int r, int c, int size)
    {
        int i;
        int **t = malloc(r * sizeof(void*));
        for(i=0; i<r; i++)
            t[i] = malloc(c * size);
        return t;
    }

    void free2d(void **arr, int r)
    {
        int i = 0;
        for(i=0; i<r; i++)

            free(arr[i]);
        free(arr);
    }

    这种方法好处是可以用a[i][j]的方式来访问数组元素，但是它需要分配额外内存来存储行指针。

    另外，这种方法分配的内存是不连续的，而且在分配和释放二维数组时，要多次调用malloc和free操作，增加了系统开销。而使用以下两种方法为二维数组分配的内存是连续的，可以避免因频繁分配和释放内存而带来的内存开销。

方法一：

    用一维数组来实现二维数组的功能，在内存中二维数组还是线性排列的。对于想申请a[m][n]数组可以如下实现：
    int   *ptr_array;
    ptr_array   =   (int*) malloc(m*n*sizeof(int));
当需要访问a[i][j]时,   用如下方式访问:  
  *(ptr_array   +   i   *   n   +   j);
当需要释放空间时，用如下方式访问：
    free ptr_array;

    这种方式实际上是把二维数组用一维数组表示,  再模拟成二维数组使用.

方法二：

void **malloc2d(int row, int col, int size)
{
    void **arr;
    arr = (void **) malloc(sizeof(void *) * row + size * row * col);
    if (arr != NULL)
    {
        void *head;
        head = (void *) arr + sizeof(void *) * row;
        memset(arr, 0, sizeof(void *) * row + size * row * col);
        while (row--)
            arr[row] = head + size * row * col;
    }
    return arr;
}

void free2d(void **arr)
{
    if (arr != NULL)
    free(arr);
}

    这种方法的好处和不足之处同Robert Sedgewick的方法一样，可以用a[i][j]的方式来访问，但仍然需要额外分配内存来存储行指针。但它分配的空间是连续的，可以避免因频繁分配和释放内存而带来的内存开销，这一点又可与方法一媲美。

最值得推荐的方法是方法二。

    C A Referenc Manual  (Fifth Edition)

    By Samuel P. Harbison III, Guy L. Steele Jr.

    这又是一本工具书级的书，该书在C语言书籍中的地位相当于Herbert Schildt的The C++: Complete Reference在C++书籍中的地位，都是经典中的经典。

    这本书的影印版从上学期就买来了，一直只是当工具书来用，没有时间系统地学习。前一段时间又开始用C写程序，写完之后就有了一股想好好复习一次C语言的冲动。于是又拿出了这本书，抽空就看看。平均每天看二三十页，零零散散看了一周多，终于把该书的第一部分看完了。

    全书分两大部分，第一部分(308页以前)讨论了C语言的所有语言特征，包括词法、预处理机制、声明、类型、表达式、语句及函数等基本语言特性。第二部分讨论了C语言的标准库。

    该书与纯粹的语言手册不同，除了分门别类并且详细地介绍语言的基本特性以外，还加入了一些说明性的实例，提供一些背景介绍或解释。该书对细节的描述毫不含糊，好些平时编程时经常拿不准的东西，都解释的很彻底很详细。读本书的时候经常有一种既之其然又知其所以然的豁然开朗的感觉。

    本书的另外一个特点就是将K&R C、ANSI C、和C99放在同一个框架里，互相对照着一起介绍。并且每一章的最后一部分都归纳了该章内容与C++标准的兼容性问题。

    该书无论作为一本参考书还是一本系统学习C语言的中级教材都非常值得推荐。

    准备下一步把第二部分(既C语言标准库)也看完。

    另外人民邮电出版的这本影印版书籍纸张还是相当不错的，又厚又白，就是字有点太小，阅读时间长了会有点累。

    C语言原本是在英文环境中设计的，主要的字符集是7位的ASCII码，8位的byte（字节）是最常见的字符编码单位。但是国际化软件必须能够表示不同的字符，而这些字符数量庞大，无法使用一个字节编码。
    C95标准化了两种表示大型字符集的方法：宽字符（wide character，该字符集内每个字符使用相同的位长）以及多字节字符（multibyte character，每个字符可以是一到多个字节不等，而某个字节序列的字符值由字符串或流（stream）所在的环境背景决定）。
    自从1994年的增补之后，C语言不只提供char类型，还提供wchar_t类型（宽字符），此类型定义在stddef.h 头文件中。wchar_t指定的宽字节类型足以表示某个实现版本扩展字符集的任何元素。
    在多字节字符集中，每个字符的编码宽度都不等，可以是一个字节，也可以是多个字节。源代码字符集和运行字符集都可能包含多字节字符。多字节字符可以被用于字符的常量、字符串字面值（string literal）、标识符（identifier）、注释（comment），以及头文件。
    C语言本身并没有定义或指定任何编码集合，或任何字符集（基本源代码字符集和基本运行字符集除外），而是由其实现指定如何编码宽字符，以及要支持什么类型的多字节字符编码机制。
    虽然C标准没有支持Unicode字符集，但是许多实现版本使用Unicode转换格式UTF-16和UTF-32（参考http://www.unicode.org）来处理宽字符。如果遵循Unicode标准，wchar_t类型至少是16或32位长，而wchar_t类型的一个值就代表一个Unicode字符。
    UTF-8是一个由Unicode Consortium（万国码联盟）定义的实现，可以表示Unicode字符集的所有字符。UTF-8字符所使用的空间大小从一个字节到四个字节都有可能。
    多字节字符和宽字符（也就是wchar_t）的主要差异在于宽字符占用的字节数目都一样，而多字节字符的字节数目不等，这样的表示方式使得多字节字符串比宽字符串更难处理。比方说，即使字符'A'可以用一个字节来表示，但是要在多字节的字符串中找到此字符，就不能使用简单的字节比对，因为即使在某个位置找到相符合的字节，此字节也不见得是一个字符，它可能是另一个不同字符的一部分。然而，多字节字符相当适合用来将文字存储成文件。
    C提供了一些标准函数，可以将多字节字符转换为wchar_t，或将宽字符转换为多字节字符。比方说，如果C 编译器使用Unicode 标准的UTF-16 和UTF-8，那么下面调用wctomb()函数就可以获得字符的多字节表示方式（注：wctomb = wide character to multibyte）。

参考：
[1] C in a Nutshell, Peter Prinz, Tony Crawford
[2] A Reference Manual, 5ed, Samuel P. Harbison III, Guy L. Steele Jr.

    如题。

    最近想写个算法并评估一下运行效率，打算用标准C来实现。

    其实从程序设计的角度来看，还是用C++更方便一些。但是C++提供的各种高级功能，如封装、继承、多态等面向对象技术，隐藏了许多底层的细节，不利于对于算法本身的优劣做评估。偶以为用C语言来评估算法是最简单和直接的。

    但我发现好久没用纯C写程序了，还真有些生疏了。从去年做项目开始，就一直用C++写程序，现在又用C#写程序。它们的抽像级别越来越高，IDE环境做得也越来越友好，编译出错输出的信息也越来越清晰。今天用C语言写了一个小程序，在VS2005下编译竟然出错，提示 ，我看着这么几行的小程序就傻了眼，怎么也找不出哪个地方错了。无耐之下我把编译器改为C++编译模式，发现一切正常，连个警告都没有。后来我仔细想了想才知道错在哪里，原来是有个变量定义的位置不对。C语言强制变量在函数或语句块的一开始就定义，而C++F却允许随用随定义，所以才出现C编译器编译出错而C++编译器却能编译通过的情况。

    重新审视C语言，拿出买来已久的 C A Reference Manual 翻了翻，发现C++和C还是有不少不一致的地方的。看来我又得好好地用用C语言了。以后写C程序尽量能同时符合C和C++标准，既所谓的Clean C程序。

[读书笔记]<The C++: Complete Reference>第四版 Herbert Schildt著 周志荣 朱德芳 于秀山 等译

    和基于C的I/O一样，C++的I/O系统是一个完全集成的系统，该系统的不同方面（例如，控制台I/O和磁盘I/O）实际上只是从不同角度看待同一种机制。

一、C++输入/输出系统基础

1.C++的流
    像基于C的I/O系统一样，C++I/O系统通过流进行操作。我们可以把流归纳如下：一个流是一种既可以产生信息又可以消耗信息的逻辑设备，它通过I/O系统与一个物理设备相连。尽管流所产生连接的设备可以完全不同，但是所有的流以同样的方式运作。因为所有流的运作方式相同，所以实际上可以利用同样的I/O函数操作所有类型的物理设备。例如，可以利用同样的函数把信息写到文件或写到打印机和屏幕。采用这种方法的优点是只需要掌握一种I/O系统。
2.C++的流类
    标准C++在头文件<iostream>中提供了对I/O系统的支持，在这个头文件中定义了一套相当复杂的层次结构以支持I/O操作。标准C++I/O类以一个模板类开始，创建了两种I/O模板类的说明：一个针对8位字符，另一个针对宽字符。
    C++I/O系统建立在两 个既相关又不同的模板类层次结构之上。第一个类层次结构是从低级I/O类派生而来，称为basic_streambuf。这个类提供基本的输入/输出操作，而且还对可个C++I/O系统提供底层支持。除非你正在进行高级的I/O编程，否则不必直接使用basic_streambuf。最常使用的类层次是从basic_ios派生而来的，这是一个高级I/O类，可以提供格式化、错误检查和与I/O相关的状态信息（一个basic_iso的基类称为ios_base，它定义了几个为basic_ios所用的非模板特性）。basic_ios用作几个派生类的基类，这些派生类包括basic_istream，basic_ostream和basic_iostream，利用这些类可以分别创建输入流、输出流和输入/输出流。要说明的一点是：ios类包含许多成员函数和变量，它们可以监控基本的流操作，而且将被频繁地引用。
3.C++的预定义流
    一个C++程序开始执行时将自动打开四个内置流，这些内置流是：

    cin，cout和cerr流与C的stdin，stdout和stderr相对应。
    默认情况下，标准流用来与控制台通信。然而，在支持I/O重定向的环境中（例如，DOS，Unix，OS/2和Windows），标准流可以被重定向到其他设备或文件。标准C++还定义了四个附加的流：win，wout，werr和wlog，它们都是宽字符版本的标准流。宽字符的类型是wchar_t，一般为16位。宽字符用于存放与一些自然语言有关的大型字符集。
4.格式化的I/O
    C++I/O系统允许你对I/O操作进行格式化。例如，可以设置域宽度、指定数字基数以及决定显示小数点后面的数字位数。有两种相互关联但概念上不同的格式化数据的方式。第一种方式可以直接访问ios类的成员，确切的说，可以设置ios类内定义的各种格式化状态标记或调用各种ios成员函数；第二种方式可以使用称之为操纵算子（manipulator）的特殊函数，该函数是I/O表达式的一部分。
5.插入器和析取器
    <<和>>运算符在C++中被重载，从而可以对C++的内置类型执行I/O操作。你还可以对这些运算符重载，以使其对你所创建的类型执行I/O操作。
    在C++中，因为<<可以把字符插入到一个流中，所以该输出运算符被称为插入运算符。同样，>>输入运算符被称为析取运算符，因为该运算符可以从 一个流中提取字符。重载插入和析取运算符的函数通常被称为插入器（inserter）和析取器（extractor）。
    通常将插入器<<和析取器>>定义为类的友员函数，此举既可以满足将插入或析取器的第一个参数作为流的一个要求，又可以保证该函数可访问重载它的类的私有成员。

二、C++文件的输入/输出

     尽管C++的I/O形成了一个完整的系统，但是文件I/O却十分特殊，以至于被普遍看做是一种特例，它们有自己的约束和特点。之所以会这样，部分是因为最常用的文件是磁盘文件，而磁盘文件有一些其他设备所有具备的性能和功能。然而要记住磁盘文件的I/O只是一般I/O系统的一个特例。
    为了执行文件的I/O，必须在程序中包括头文件<fstream>。该头文件定义了一些类，其中包括ifstream，ofstream和fstream，这些类分别从istream，ostream和iostream派生而来。记住，因为istream，ostream和iostream是从ios派生而来的，所以ifstream，ofstream和fstream同样可以访问ios定义的所有操作。文件系统使用的另一个类是filebuf，这个类提供用于管理文件流的低级功能程序，通常情况下，我们不直接使用filebuf，而是将其作为其他文件类的一部分。

[读书笔记]<The C++: Complete Reference>第四版 Herbert Schildt著 周志荣 朱德芳 于秀山 等译

    C++支持两种I/O系统。第一种是从C中继承来的，第二种是由C++定义的面向对象的I/O系统。本文上篇讨论C语言的I/O子系统，下篇将讨论C++的I/O系统。
    在C语言中，输入和输出是通过库函数来完成的。既有控制台函数，也有文件I/O函数。从技术上讲，控制台I/O和文件I/O之间只有很小的差别。然而，从概念上讲，它们是两个截然不同的范畴。标准CI/O函数都是使用头文件stdio.h。C++程序也可以使用C++风格的头文件<cstdio>。

一、C风格的控制台I/O
    控制台I/O函数从键盘输入并输出到屏幕上。然而，这些函数实际上让系统的标准输入和标准输出作为它们的I/O操作的目的和源。此外，标准输入和标准输出也可重定向到其他设备。
1.最简单的控制台I/O函数是getchar()和putchar()
    其原型如下：
  int getchar(void);
  int putchar(int c);
2.gets()和puts()是控制台I/O中更复杂、更高效率的函数，它们使你能够读写字符串。
    其原型如下：
  char *gets(char *str);
  int puts(const char *str);
3.格式化的控制台I/O
    printf()和scanf()是两个实现格式化输入输出的函数。它们在用户的控制下以不同的格式读写数据。两者都可以操作包括字符、字符串和数字在内的任何内嵌数据类型。其原型如下：
  int prinf(const char *control_string,...);
  int scanf(const char *control_string,...);

二、C风格的文件I/O
    在开始讨论C语言的文件系统之前，了解流和文件这两个概念之间的差别是很重要的。C的I/O系统给程序员提供了一个独立于设备进行信息访问的友好界面。即，C的I/O系统在程序员和实际设备之间提供了一级抽象，这个抽象称为流，而物理设备称为文件。
1.流
    C文件系统可在包括终端、磁盘驱动器和磁带驱动器等众多设备上工作。不管设备有多大差异，文件系统都把它们转换成“流”的逻辑设备，且所有流的行为是类似的。因为流具有极大的设备无关性，所以向一个磁盘文件进行写操作的同一个函数也可以完成向另一种设备（如控制台）的写操作。有两种类型的流：文本流和二进制流。
    文本流由一系列字符组成，标准C允许（但不要求）一个文本被组织成多行，以换行符终止一行。然而，在最后一行上换行符是可选的（实际上，大多数C/C++编译器都不需要使用换行符终止文本流）。在文本中，特定字符的转换是由主机环境要求的，例如，新行可以被转换成回车/换行符对。因而，被写（或读）的字符与存储在外设中的字符之间并无一一对应的关系。同样，由于可能的转换，被写（或读）的字符的数量可能与外设中存储的字符不一致。
    二进制流是指一系列字节，这一系列字节与外设中存储的字节有一对一的头关系，也就是说，不存在字符转换。此外，写（或读）字节的数量与外设中存储的字节数相同。然而，根据实现决定的空字节数可以追加到一个二进制流中。例如，这些空字节有时用来补充信息以填满磁盘的某个扇区。
2.文件
    在C/C++中文件可以是从磁盘文件到终端或打印机的任何东西。流通过执行打开操作与某个文件联系起来。文件一旦打开，里面的信息就可能在程序与该文件之间交换。
    并非所有文件都有相同的功能。例如，磁盘文件支持随机访问，但某些打印机却不行。这就说明了C语言中I/O系统的一个重要特征：所有的流都是相同的，但文件却不同。
    如果文件支持定位请求，那么打开文件也使文件位置指针初始化到文件的开始处。当字符从某个文件中读出或写到某个文件中时，文件位置指针加1，从而确保可以遍历整个文件。
    文件通过关闭操作与特定流断开连接。当关闭一个为输出而打开的文件时，与它相关的流的内容（如果存在的话）被写到外设中。这一过程通常称为“清空”流，它保证了在磁盘缓冲区中不留下任何信息。当程序正常终止时所有文件都自动关闭，其关闭方式是要么通过返回到操作系统的main()，要么通过调用exit()。如果程序员因故障崩溃或调用abort()而终止，则文件不关闭。
    与文件相关的流都有一个类型为FILE的文件控制结构。永远都不要对它进行任何修改操作。
3.标准流
    虽然与C文件系统有关，程序一旦开始执行，就有三种流被自动打开。它们是标准输入（stdin）、标准输出（stdout）及标准错误（stderr）。通常，它们对应于控制台、但也可以通过操作系统重定向到支持可以重定向I/O环境（如Windows,Unix,OS/2和Dos）的其它设备中。
    通常，stdin用于从控制台读，stdout用于从控制台写，stderr也用于从控制台写。可以在使用FILE*类型变量的任何函数中，把stdin，stdout和stderr当作文件指针使用。
    例如，putchar()可以定义如下：
int putchar(char c)
{
    return putc(c, stdout);
}
    再例如，可以使用fgets()从控制台输入一个字符口串，按如下方式调用：
char str[255];
fgets(str, 80, stdin);
    事实上，按这种方式使用fgets()是相当有用的。因为，当使用gets()时，可能越出数组的边界（现在正使用该数组来接收由用户键入的字符），因为gets()为提供边界检查。当和stdin一起使用时，fgets()提供了一个有用的替代物，因为它能限制所读的字符数，因而防止数组越界。惟一的麻烦是fgets()没有删除换行符而gets()删除了，所有你不得不手工删除它，如下面的程序所示：
#include <stdio.h>
#include <string.h>
int main(void)
{
    char str[80];
    int i;

    printf("Enter a string: ");
    fgets(str, 10, stdin);

    /*remove newline, if present*/
    i = strlen(str)-1;
    if(str[i] == '\n') str[i] = '\0';

    printf("This is your string: s", str);

    return 0;
}
    记住，stdin，stdout和stderr不是普通变量，也不能通过fopen()进行赋值。还有，像这些文件指针在程序执行时自动创建一样，它们在结束时自动关闭，用户无法随意关闭它们。
4.控制台I/O连接
    实际上，控制台I/O和文件I/O之间的区别很小。控制台I/O函数通过stdin或stdout完成I/O操作。实际上，控制台I/O函数只是一些并行文件函数的特例，它们的存在只是为了方便程序员。
    正如上面3中所描述的那样，可以利用任何文件系统函数来完成控制台I/O。然而，最令人惊奇的是还可以使用控制台I/O函数来操作文件，如prinf()来完成磁盘文件I/O。这是因为所有的控制台I/O函数都操作于stdin和stdout。在允许I/O重定向的环境中，这意味着stdin和stdout可对应于包括键盘和屏幕的其他设备。例如，考虑如下程序：
#include <stdio.h>
int main(void)
{
    char str[80];

    printf("Enter a string: ");
    gets(str);
    printf(str);

    return 0;
}

    假定这个程序称为TEST，如果正常执行TEST，则在屏幕上显示提示，从键盘中读一个串，然后将该串显示在屏幕上。然而，在支持I/O重定向的环境中，stdin，stdout或两者都能被重定向到一个文件中。例如，在DOS或Windows环境中，执行TEST如下：
  TEST > OUTPUT
于是TEST的输出结果写到了OUTPUT文件中。若执行如下：
  TEST < INPUT > OUTPUT
stdin被导向INPUT文件中，并发送输出到OUTPUT文件中。
    当程序终止时，任何重定向流都复位到它们的默认状态。
5.使用freopen()来重定向标准流
    使用freopen()可以重定向标准流。这个函数用于将某一现存流与一个新文件联系起来。因此，可以用它将一个标准流与一个新文件联系起来。它的原型是：
  FILE *freopen(const char *filename, const char *mode, FILE *stream);
    其中，filename是一个指向你希望与stream指向的流相关联的文件名的指针。该文件以mode值方式打开，与fopen()相同。如果成功则返回流，否则，返回NULL指针。
    下面的程序使用freopen()来重定向stdout到OUTPUT文件。
#include <stdio.h>
int mai(void)
{
    char str[80];

    freopen("OUTPU", "w", stdout);

    printf("Enter a string: ");
    gets(str);
    printf(str);

    return 0;
}
    通常，用freopen()重定向标准流在一些特殊情况下（例如调试）是很有用的。然而，通过重定向stdin和stdout来完成磁盘I/O不一定与用fread()和fwrite()函数一样有效。

　　在开发有关bitmap方面的程序时，经常需要将位图的颜色在RGB和HSV色彩空间之间转换，下面是该颜色转换的C++实现：

RGB颜色空间转换为HSV空间颜色值：

void Rgb2Hsv(float R, float G, float B, float& H, float& S, float&V)
{
     // r,g,b values are from 0 to 1
    // h = [0,360], s = [0,1], v = [0,1]
    // if s == 0, then h = -1 (undefined)

    float min, max, delta,tmp;
    tmp = min(R, G);
    min = min( tmp, B );
    tmp = max( R, G);
    max = max(tmp, B );
    V = max; // v

    delta = max - min;

    if( max != 0 )
      S = delta / max; // s
    else
    {
       // r = g = b = 0 // s = 0, v is undefined
      S = 0;
      H = UNDEFINEDCOLOR;
      return;
    }
    if( R == max )
        H = ( G - B ) / delta; // between yellow & magenta
   else if( G == max )
        H = 2 + ( B - R ) / delta; // between cyan & yellow
   else
        H = 4 + ( R - G ) / delta; // between magenta & cyan

    H *= 60; // degrees
    if( H < 0 )
       H += 360;
}

HSV颜色空间转换为RGB空间颜色值：

void Hsv2Rgb(float H, float S, float V, float &R, float &G, float &B)
{
     int i;
    float f, p, q, t;

    if( S == 0 )
    {
    // achromatic (grey)
        R = G = B = V;
        return;
    }

    H /= 60; // sector 0 to 5
    i = floor( H );
    f = H - i; // factorial part of h
    p = V * ( 1 - S );
    q = V * ( 1 - S * f );
    t = V * ( 1 - S * ( 1 - f ) );

    switch( i )
    {
    case 0:
        R = V;
        G = t;
        B = p;
       break;
    case 1:
       R = q;
       G = V;
       B = p;
       break;
    case 2:
       R = p;
       G = V;
       B = t;
       break;
    case 3:
       R = p;
       G = q;
       B = V;
       break;
    case 4:
       R = t;
       G = p;
       B = V;
       break;
    default: // case 5:
       R = V;
       G = p;
       B = q;
       break;
    }
}