久久久综合精品,欧美色大人视频,欧美在线观看视频一区二区三区

zhaoyg — Wed, 02 May 2012 16:12:00 GMT

此刻我本已在床上睡觉了，但就在我睡前��ȝ��《深度探索C++对象模型》时我看��C��一�D�内容，也就是这�D�内容��得我写下了这��笔记�?/span>

�q�段内容大致讲的是关于模板中的命名决议：“scope of the template definition”�?#8220;scopy of the template instantition”�?/span>

坦白的说我是�W�一�ơ看到这一知识点，在上机验证后又回惟뀊C++ Primer�?4th中可曾有提及�q�，后来发现4th中没有，倒是3rd中有专门的一��节专门陈述了下�?br />
后来我在《深度探索C++对象模型》书中关于模板中命名册��内容的旁边写下了�q�样一�D�话�Q?br />
今天才发现还有这么个东西。我只能承认自己的无知与C++的变态，面对�q�一知识炏V�?br /> 2012.5.2 �?br />

zhaoyg 2012-05-03 00:12 发表评论

zhaoyg — Fri, 19 Aug 2011 13:06:00 GMT

赖勇��（http://laiyonghao.com�Q?br /> 声明�Q�本文源�?Danny Kalev �?2011 �q?6 �?21 日发表的《The Biggest Changes in C++11(and Why You Should Care)》一文，几乎所有内定w��搬了�q�来�Q�但不是全文照译�Q�有困惑之处�Q�请参详原文�Q?a >http://www.softwarequalityconnection.com/2011/06/the-biggest-changes-in-c11-and-why-you-should-care/ �Q��?br /> 注：作�?Danny Kalev 曾是 C++ 标准委员会成员�?/p>

Lambda 表达�?/h2>
Lambda 表达式的形式是这��L��Q?br />
view plain
[capture](parameters)->return-type {body}

来看个计数某个字�W�序列中有几个大写字母的例子�Q?br />
view plain
int main()
{
   char s[]="Hello World!";
   int Uppercase = 0; //modified by the lambda
   for_each(s, s+sizeof(s), [&Uppercase] (char c) {
    if (isupper(c))
     Uppercase++;
    });
cout<< Uppercase<<" uppercase letters in: "<< s<
}

其中 [&Uppercase] 中的 & 的意义是 lambda 函数体要获取一�?Uppercase 引用�Q�以便能够改变它的��|��如果没有 &�Q�那��?Uppercase ��以传值的形式传递过厅R�?

自动�c�d��推导�?decltype

�?C++03 中，声明对象的同时必��L��明其�c�d��Q�其实大多数情况下，声明对象的同时也会包括一个初始��|��C++11 在这�U�情况下��p��够让你声明对象时不再指定�c�d��了：

view plain

auto x=0; //0 �?nbsp;int �c�d��Q�所�?nbsp;x 也是 int �c�d��
auto c='a'; //char
auto d=0.5; //double
auto national_debt=14400000000000LL;//long long

�q�个�Ҏ(gu��)��在对象的类型很大很长的时候很有用�Q�如�Q?br />

view plain

void func(const vector &vi)
{
vector<int>::const_iterator ci=vi.begin();
}

那个�q�代器可以声明�ؓ�Q?br />

view plain

auto ci=vi.begin();

C++11 也提供了从对象或表达式中“俘获”�c�d��的机�Ӟ��新的操作�W?decltype 可以从一个表辑ּ��?#8220;俘获”其结果的�c�d��q?#8220;�q�回”�Q?br />

view plain

const vector vi;
typedef decltype (vi.begin()) CIT;
CIT another_const_iterator;

�l�一的初始化语法

C++ 最��有 4 �U�不同的初始化�Ş式，如括号内初始化，见：

view plain

std::string s("hello");
int m=int(); //default initialization

�q�有�{�号形式的：

view plain

std::string s="hello";
int x=5;

对于 POD 集合�Q�又可以用大括号�Q?br />

view plain

int arr[4]={0,1,2,3};
struct tm today={0};

最后还有构造函数的成员初始化：

view plain

struct S {
int x;
S(): x(0) {} };

�q�么多初始化形式�Q�不仅菜鸟会搞得很头大，高手也吃不消。更惨的�?C++03 中居然不能初始化 POD 数组的类成员�Q�也不能在��?new[] 的时候初�?POD 数组�Q�操蛋啊�Q�C++11 ��q��大括号一�l�天下了�Q?br />

view plain

class C
{
int a;
int b;
public:
C(int i, int j);
};
C c {0,0}; //C++11 only. 相当�?nbsp;C c(0,0);
int* a = new int[3] { 1, 2, 0 }; /C++11 only
class X {
int a[4];
public:
X() : a{1,2,3,4} {} //C++11, 初始化数�l�成�?nbsp;
};

�q�有一大好事就是对于容器来��_��l�于可以摆脱 push_back() 调用了，C++11中可以直观地初始化容器了�Q?br />

view plain

// C++11 container initializer
vector vs={ "first", "second", "third"};
map singers =
{ {"Lady Gaga", "+1 (212) 555-7890"},
{"Beyonce Knowles", "+1 (212) 555-0987"}};

而类中的数据成员初始化也得到了支持：

view plain

class C
{
int a=7; //C++11 only
public:
C();
};

deleted 函数�?defaulted 函数

像以下�Ş式的函数�Q?br />

view plain

struct A
{
A()=default; //C++11
virtual ~A()=default; //C++11
};

叫做 defaulted 函数�Q?default; 指示�~�译器生成该函数的默认实现。这有两个好处：一是让�E�序员轻松了�Q�少敲键盘，二是有更好的性能�?br /> �?defaulted 函数相对的就�?deleted 函数�Q?br />

view plain

int func()=delete;

�q�货有一大用途就是实�?noncopyabe 防止对象拯��Q�要想禁止拷贝，�?=deleted 声明一下两个关键的成员函数��可以了�Q?br />

view plain

struct NoCopy
{
NoCopy & operator =( const NoCopy & ) = delete;
NoCopy ( const NoCopy & ) = delete;
};
NoCopy a;
NoCopy b(a); //�~�译错误�Q�拷贝构造函数是 deleted 函数

nullptr

nullptr 是一个新�?C++ 关键字，它是�I�指针常量，它是用来替代高风险的 NULL 宏和 0 字面量的。nullptr 是强�c�d��的：

view plain

void f(int); //#1
void f(char *);//#2
//C++03
f(0); //调用的是哪个 f?
//C++11
f(nullptr) //毫无疑问�Q�调用的�?nbsp;#2

所有跟指针有关的地斚w��可以�?nullptr�Q�包括函数指针和成员指针�Q?br />

view plain

const char *pc=str.c_str(); //data pointers
if (pc!=nullptr)
cout<
int (A::*pmf)()=nullptr; //指向成员函数的指�?nbsp;
void (*pmf)()=nullptr; //指向函数的指�?nbsp;

委托构造函�?/h2>
C++11 中构造函数可以调用同一个类的另一个构造函敎ͼ�

view plain
class M //C++11 delegating constructors
{
int x, y;
char *p;
public:
M(int v) : x(v), y(0),  p(new char [MAX])  {} //#1 target
M(): M(0) {cout<<"delegating ctor"<

#2 ��是所谓的委托构造函敎ͼ�调用了真正的构造函�?#1�?

叛_��引�?/h2>
�?C++03 中的引用�c�d��是只�l�定左值的�Q�C++11 引用一个新的引用类型叫叛_��引用类型，它是�l�定到右值的�Q�如临时对象或字面量�?br /> 增加叛_��引用的主要原因是�ؓ了实�?move 语义。与传统的拷贝不同，move 的意思是目标对象“�H�取”原对象的资源�Q��ƈ��源�|�于“�I?#8221;状态。当拯��一个对象时�Q�其实代��h��贵且无必要，move 操作��可以替代它。如�? string 交换的时候，使用 move 意义��有巨大的性能提升�Q�如原方案是�q�样的：

view plain
void naiveswap(string &a, string & b)
{
string temp = a;
a=b;
b=temp;
}

�q�种�Ҏ(gu��)��很傻很天真，很慢�Q�因为需要申请内存，然后拯��字符�Q��?move ��只需要交换两个数据成员，无须甌��、释攑ֆ�存和拯��字符数组�Q?br />
view plain
void moveswapstr(string& empty, string & filled)
{
//pseudo code, but you get the idea
size_t sz=empty.size();
const char *p= empty.data();
//move filled's resources to empty
empty.setsize(filled.size());
empty.setdata(filled.data());
//filled becomes empty
filled.setsize(sz);
filled.setdata(p);
}

要实现支�?move 的类�Q�需要声�?move 构造函数和 move 赋值操作符�Q�如下：

view plain
class Movable
{
Movable (Movable&&); //move constructor
Movable&& operator=(Movable&&); //move assignment operator
};

C++11 的标准库�q�泛使用 move 语义�Q�很多算法和容器都已�l��?move 语义优化�q�了�?

C++11 的标准库

�?TR1 包含的新容器�Q�unordered_set, unordered_map, unordered_multiset, 和unordered_multimap�Q�，�q�有一些新的库�Q�如正则表达式，tuple�Q�函数对象封装器�{�。下面介�l�一�?C++11 的标准库新特性：

�U�程�?/h3>
从程序员的角度来看，C++11 最重要的特性就是�ƈ发了。C++11 提供�?thread �c�，也提供了 promise �?future 用以�q�发环境中的同步�Q�用 async() 函数模板执行�q�发��d��Q�和 thread_local 存储声明为特定线�E�独占的数据�Q�这里（http://www.devx.com/SpecialReports/Article/38883�Q�有一个简�?�?C++11 �U�程库教�E�（英文�Q��?/p>

新的��指针�c?/h3>
C++98 定义的唯一的智能指针类 auto_ptr 已经被弃用，C++11 引入了新的智能针对类 shared_ptr �?unique_ptr。它们都是标准库的其它组件兼容，可以安全地把��指针存入标准容器�Q�也可以安全地用标准��法“倒腾”它们�?/p>

新的��法

主要�?all_of()、any_of() �?none_of()�Q�下面是例子�Q?br />

view plain

#include
//C++11 code
//are all of the elements positive?
all_of(first, first+n, ispositive()); //false
//is there at least one positive element?
any_of(first, first+n, ispositive());//true
// are none of the elements positive?
none_of(first, first+n, ispositive()); //false

�q�有一个新�?copy_n�Q?br />

view plain

#include
int source[5]={0,12,34,50,80};
int target[5];
//�?nbsp;source 拯�� 5 个元素到 target
copy_n(source,5,target);

iota() ��法可以用来创徏递增序列�Q�它先把初��D��值给 *first�Q�然后用前置 ++ 操作�W�增长初值�ƈ赋值到�l�下一个�P代器指向的元素，如下�Q?br />

view plain

#include
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}

是的�Q�C++11 仍然�~�少一些很有用的库�?XML API�Q�socket�Q�GUI、反��?#8212;—以及自动垃圾攉��。然而现有特性已�l�让 C++ 更安全、高效（是的�Q�效率更高了�Q�可以参�?Google �? 基准��试�l�果http://www.itproportal.com/2011/06/07/googles-rates-c-most- complex-highest-performing-language/�Q�以及更加易于学习和使用�?br /> 如果觉得 C++ 变化太大了，不必惊恐�Q�花�Ҏ(gu��)��间来学习��好了。可能在你融会诏通新�Ҏ(gu��)��以后，你会同意 Stroustrup 的观点：C++11 是一门新的语�a�——一个更好的 C++�?p>

zhaoyg 2011-08-19 21:06 发表评论

【�{】B(t��i)OOST的编译选项

zhaoyg — Wed, 16 Feb 2011 03:35:00 GMT

原文�Q?a href="http://m.shnenglu.com/flyinghare/archive/2010/09/07/126078.aspx">http://m.shnenglu.com/flyinghare/archive/2010/09/07/126078.aspx

许多��C�h对于�~�译B(t��i)OOST感到无从下手�Q�甚臛_��此而放弃��用BOOST�Q�那真的太可惜了�Q�下面我把一些常用的BOOST�~�译�Ҏ(gu��)��贴于此，同时也作��q��W�记�?
首先下蝲bjam.exe�Q�复制到 $BOOST$ 目录下。或�?span style="FONT-SIZE: 14pt">自己生成bjam�Q�打开Visual Studio 2008 命��o提示�H�口$BOOST$\tools\jam\src�Q�执�?build.bat 会在$BOOST$\tools\jam\src\bin.ntx86 生成 bjam.exe 文�g。复制文�?bjam.exe 文�g�?$BOOST$\�?/span>�?

1.完全�~�译安装�Q?
bjam --toolset=msvc install
完成后会生成一个bin.v2�~�译时的临时目录�Q�手动删除。生成另一个目录C:\boost�Q�里面�ؓ所有的头文件和库文件。头文�g目录为boost_1_34_1\boost目录复制�q�去的�?br>
2.只编译相应的库文�?
bjam --toolset=msvc stage
完成后同样会生成bin.v2临时目录。另一个目录�ؓstage文�g�Q�里面有对应的库文�g�?

3.查看需要编译才能��用的库列�?
bjam --show-libraries

4.�~�译特定的库�Q�如只编译regex
bjam --toolset=msvc --with-regex stage
生成的库文�g在stage目录中�?

5.不编译某个库�Q�如不编译regex
bjam --toolset=msvc --without-regex stage
生成的库文�g在stage目录中�?

6.�~�译特定的库�Q�如只编译regex�Q�生成debug�Q�多�U�程�Q�共享连接版本，�q�保存在stage�?
bjam --toolset=msvc --with-regex stage debug threading=multi link=shared

7.生成 mt-sgd 的静态库(runtime-link-static)
bjam "-sTOOLS=vc-8_0" --with-thread install debug release runtime-link=static

8.�~�译regex库�?
bjam --toolset=msvc --with-regex stage debug release threading=multi threading=single link=shared link=static runtime-link=shared runtime-link=static

boost的安装方法：
对于DLL版本
bjam --toolset=msvc link=shared runtime-link=shared threading=multi stage debug release install

对于lib版本
bjam --toolset=msvc link=static runtime-link=shared threading=multi stage debug release install

另外�Q�在$BOOST$\tools\build\v2\user-config.jam扑ֈ�下面的地�?
# -------------------
# MSVC configuration.
# -------------------
# Configure msvc (default version, searched for in standard locations and PATH).
# using msvc ;
# Configure specific msvc version (searched for in standard locations and PATH).
# using msvc : 8.0 ;
#在这里添�?vs2008 的配�|?
using msvc : 9.0 : : /wd4819 /D_CRT_SECURE_NO_DEPRECATE /D_SCL_SECURE_NO_DEPRECATE /D_SECURE_SCL=0 ;
#在这里添�?vs2005 的配�|?
using msvc : 8.0 : : /wd4819 /D_CRT_SECURE_NO_DEPRECATE /D_SCL_SECURE_NO_DEPRECATE /D_SECURE_SCL=0 ;
然后�q�入 $BOOST$ 目录�Q�执行bjam.exe �~�译命��o
//下面的命令的各选项的说明：
//prefix    ��boost安装到的路径�Q�生成的头文件和库文仉��会放到该路径中）�?
//重定义以下变量（利用-s讄��Q�：
//VC80_ROOT　　 vc2005的安装�\径，如果未将vc2005安装到默认位�|�，你必��L��定该��V�?
//TOOLS         使用的编译工��P��vc2005对应的是vc-8_0
//PYTHON_ROOT   ython的安装目录，如果未将BOOST安装到默认位�|�，你必��L��定该��V�?
//BUILD         �~�译�l�果选项�Q�默认会生成��可能多的版本，如调试版�Q�发行版�Q�静态库�Q�动态库�Q�单�U�程�Q�多�U�程�?

zhaoyg 2011-02-16 11:35 发表评论

【�{】function/bind的救赎（上）

zhaoyg — Thu, 20 Jan 2011 14:24:00 GMT

转自�Q?a >http://blog.csdn.net/myan/archive/2010/10/09/5928531.aspx
作者：孟岩
--------------------------------------------------------------------------------------
�q�是那篇C++0X的正文。太长，先写上半部分发了�?/p>

Function/bind可以是一个很��单的话题�Q�因为它其实不过��是一个泛型的函数指针。但是如果那么来谈，��没意思了�Q�也犯不上写�q�篇东西。在我看来，�q�个事情要讲的话�Q�就应该讲透，讲到回调�Q�callback�Q�、代理（delegate�Q�、信��P��signal�Q�和消息传递（messaging�Q�的层面�Q�因为它��实是太重要了。这个话题不但与面向对象的核心思想密切相关�Q�而且是面向对象两大流�z�之间交锋的中心。围�l�这个问题的思考和争论�Q�几乎把20�q�来所有主��的�~�程�q�_��和编�E�语�a�都搅�q�来了。所以，如果详尽铺陈�Q�这个话题直接可以写一本书�?/p>

写书我当然没那个水��^�Q�但�q�个题目��实一直想动一动。然而这个主题实在太大，我实在没有精力把它完整的写下来；�q�个主题也很深，特别是涉及到�q�发环境有关的话题，我的理解�q�非常肤��，总觉得我认识的很多高手都比我更有资格写这个话题。所以犹豫了很久�Q�要不要现在写，该怎么写。最后我觉得�Q�确实不能把一��博客文章写成一�?0�q�面向对象技术史讎ͼ�所以决定保留大的架构，但是对其中具体的技术细节点��Cؓ止。我不会去详�l�地列�D代码�Q�分析对象的内存布局�Q�画�C�意图，但是会把最重要的结论和观点写下来，说得好听一�Ҏ(gu��)��提纲挈领�Q�说的不好听��是语焉不详。但无论如何�Q�我惌��样一��东西，一是谈谈我对这个事情的看法�Q�二�?#8220;抛砖引玉”�Q�引来高手的��x��Q�引出更深刻和完整的叙述�?/p>

下面开始�?/p>

0. �E�序设计有一个范式（paradigm�Q�问题。所谓范式，��是�l�织�E�序的基本思想�Q�而这个基本思想�Q�反映了�E�序设计者对�E�序的一个基本的哲学观，也就是说�Q�他认�ؓ�E�序的本质是什么，他认��Z��个大的程序是�׃��么组成的。而这�Q�又跟他对于现实世界的看法有兟뀂显�Ӟ��q�样的看法不可能有很多种。编�E�作��Z��门行业，独立存在�?0�q�了�Q�但是所出现的范式不�q�三�U�——过�E�范式、函数范式、对象范式。其中函数范式与现实世界差距比较大，在这里不讨论。而过�E�范式和对象范式可以视�ؓ对程序本质的两种�Ҏ(gu��)��不同的看法，而且能够分别在现实世界中扑ֈ�相应的映��?br>�q�程范式认�ؓ�Q�程序是�׃��个又一个过�E�经�q�顺序、选择和��@环的�l�构�l�合而成。反映在现实世界�Q�过�E�范式体��C��力_��分工之前“全能�?#8221;的工作特点——所有的事情都能�qԌ��所有的资源都是我的�Q�只不过得具体的事情得一步步地来做�?
对象范式则反映了力_��分工之后的团队协作的工作特点——每个�h各有所长，各司其职�Q�有各自的私有资源，工�g和信息在��Z��之间彼此传递，最后完成工作。因此，对象范式也就形成了自己对�E�序的看法——程序是�׃��l�对象组成，�q�些对象各有所能，通过消息传递实现协作�?

对象范式与过�E�范式相比，有三个突出的优势�Q�第一�Q�由于实��C��逻辑上的分工�Q�降低了大规模程序的开发难度。第二，灉|��性更好——若�q�对象在一��P��可以灉|��l�合�Q�可以以不同的方式协作，完成不同的�Q务，也可以灵�zȝ��替换和升�U�。第三，对象范式更加适应囑�Ş化、网�l�化、消息驱动的��C��计算环境�?/p>

所以，较之于过�E�范式，对象范式�Q�或者说“面向对象”�Q�确实是更具优势的编�E�范式。最�q�看��C��些文章抨击面向对象，说面向对象是胡扯�Q�我认�ؓ要具体分析。对面向对象的一部分批评�Q�是冲着��L��?#8220;面向对象”语言�ȝ��Q�这��实是有道理的，我在下面也会谈到�Q�而且会骂得更狠。而另一个批评的声音�Q�主要而来自STL之父Alex Stepanov�Q�他说的当然有他的道理，不过要知道该牛�h是前苏联莫斯�U�国立罗蒙诺索夫大学数学�p�d��士，你只要翻��d��苏联的大学数学教材就知道了，能够在莫大拿到数学博士的�Q�根本就是披着人皮的外星高�{�智慧。而我们编写地球上的程序，可能�q�是应该以地球�h的观点�ؓ丅R�?/p>

1. 重复一遍对象范式的两个基本观念�Q?br>�E�序是由对象�l�成的；
对象之间互相发送消息，协作完成��d��Q?

��h��意，�q�两个观念与后来我们熟知的面向对象三要素“��装、��ѝ��多�?#8221;�Ҏ(gu��)��不在一个层面上�Q�倒是与再后来�?#8220;�l��g、接�?#8221;��合�?/p>

2. 世界上第一个面向对象语�a�是Simula-67�Q�第二个面向对象语言是Smalltalk-71。Smalltalk受到了Simula-67的启发，基本出发点相同，但也有重大的不同。先说相同之处，Simula和Smalltalk都秉承上�q�对象范式的两个基本观念�Q��ؓ了方便对象的构造，也都引入了类、��承等概念。也��是��_��c�R��承这些机制是��Z��实现对象范式原则而构造出来的�W�二位的、工��h��的机制�Q�那么�ؓ什么后来这些第二位的东西篡了主位，后面我会再来分析。而Simula和Smalltalk最重大的不同，��是Simula用方法调用的方式向对象发送消息，而Smalltalk构造了更灵�z�d��更纯�_�的消息发送机制�?/p>

具体的说�Q�向一个Simula对象中发送消息，��是调用�q�个对象的一个方法，或者称成员函数。那么你怎么知道能够在这个对象上调用�q�个成员函数呢？或者说�Q�你怎么知道能够向这个对象发送某个消息呢�Q�这��p��求你必须��保�q�个对象��h��合适的�c�d��Q�也��是��_��你得先知道哦�q�个对象是什么，才能向它发消息。而消息的实现方式被直接处理�ؓ成员函数调用�Q�或虚函数调用�?/p>

而Smalltalk在这一点上做了一个历史性的跨越�Q�它实现了一个与目标对象无关的消息发送机�Ӟ��不管那个对象是谁�Q�也不管它是不是能正��的处理一个消息，作�ؓ发送消息的对象来说�Q�可以毫无顾忌地抓住一个对象就发消息过厅R��接到消息的对象�Q�要��试理解�q�个消息�Q��ƈ最后调用自��q��q�程来处理消息。如果这个消息能被处理，那个对象自然会处理好�Q�如果不能被处理�Q�Smalltalk�pȝ��会向消息的发送者回传一个doesNotUnderstand消息�Q�予以通知。对象不用关心消息是如何传递给另一个对象的�Q�传递过�E�被分离出来�Q�而不是像Simula那样明确地被以成员函数调用的方式实现�Q�，可以是在内存中复�Ӟ��也可以是�q�程间通讯。到了Smalltalk-80�Ӟ��消息传递甚臛_��以跨��网�l��?/p>

��Z��方便后面的讨论，不妨把源自Simula的消息机制称�?#8220;静态消息机�?#8221;�Q�把源自Smalltalk的消息机制称�?#8220;动态消息机�?#8221;�?/p>

Simula与Smalltalk之间对于消息机制的不同选择�Q�主要是因�ؓ两者于用途。前者是用于仿真�E�序开发，而后者用于图形界面环境构建，看上��d��自合情合理。然而，��是�q�么一点简单的区别�Q�却造成了巨大的历史后果�?/p>

3. ��C��1980�q�代�Q�C++出现了。Bjarne Stroustrup在博士期间深入研�I�过Simula�Q�非常欣赏其思想�Q�于是就在C语言语法的基��之上�Q�几乎把Simula的思想照搬�q�来�Q��Ş成了最初的C++。C++问世以之初，主要用于解决规模�E�大的传�l�类型的�~�程问题�Q�迅速取得了巨大的成功，也证明了对象范式本��n所��h��的威力�?/p>

大约在同期，Brad Cox�Ҏ(gu��)��Smalltalk的思想设计了Objective-C�Q�可是由于其语法怪异�Q�没有流行�v来。只有Steve Jobs�q�种��h��宗��学鉴赏力的世外高�h�Q�把它奉为瑰宝，�?988�q�连锅把Objective-C的团队和产品一口气��C��下来�?/p>

4. ��在同一时期�Q�GUI成�ؓ热门。虽然GUI的本质是对象范型的，但是当时�Q?980�q�代中期�Q�的面向对象语言�Q�包括C++语言�Q�还�q�不成熟�Q�因此最初的GUI�pȝ��无一例外是��用C和汇�~�语�a�开发的。或者说�Q�最初的GUI开发者硬是用抽象�U�别更低的语�a�构造了一个面向对象系�l�。熟�(zh��n)�Win32 SDK开发的人，应该知道我在说什么�?/p>

5. 当时很多��Z��为，如果C++更成熟些�Q�直接用C++来构造Windows�pȝ��会大大地�Ҏ(gu��)��。也有�h觉得�Q�尽��Windows�pȝ��本��n使用C写的�Q�但是其面向对象的本质与C++更契合，所以在其基��上包装一个C++的GUI framework一定是轻而易举。可是一动手��Z��发玎ͼ�完全不是那么回事。用C++开发Windows框架隑־�要死。�ؓ什么呢�Q�主要就是Windows�pȝ��中的消息机制实际上是动态的�Q�与C++的静态消息机制根本配合不��C��起去。在Windows里，你可以向��M��一个窗口发送消息，�q�个�H�口自己会在自己的wndproc里来处理�q�个消息�Q�如果它处理不了�Q�就交给default window/dialog proc��d��理。而在C++里，你要向一个窗口发消息�Q�就得确保这个窗口能处理�q�个消息�Q�或者说�Q�具有合适的�c�d��。这样一来的话，��׃��D��一个错�l�复杂的�H�口�c�d��ơ结构，无法实现。而如果你要让所有的�H�口�c�都能处理所有可能的消息�Q�且不论�q�样在逻辑上就行不通（用户定义的消息怎么处理�Q�）�Q�单在实��C��׃��可接受——�ؓ一个小��的不同��得创造一个新的窗口类�Q�每一个小��的�H�口�c�都要背上一个多达数��N��的v-table�Q�而其中可�?9%的项都是��费�Q�不要说在当�Ӟ��是在今天，内存数量非常丰富的时候，如果每一个GUI�E�序都这么搞�Q�用户也吃不消�?/p>

6. 实际上C++的静态消息机制还引�v了更�׃��重的问题——扭曲了��Z��寚w��向对象的理解。既然必��要先知道对象的�c�d��Q�才能向对象发消息，那么“�c?#8221;�q�个概念��q��别重要了�Q�而对象只不过是类�q�个模子里造出来的东西�Q�反而不重要。渐渐的�Q?#8220;面向对象�~�程”变成�?#8220;面向�cȝ��E?#8221;�Q?#8220;面向�cȝ��E?#8221;变成�?#8220;构造类�l�承�?#8221;。放在眼前的鲜活的对象活动不重要了，反而是其背后的静态类型系�l�成为关键�?#8220;��装、��?#8221;�q�些�W�二�{�的�Ҏ(gu��)��，喧宾��Z��Q�俨然成了面向对象的要素。每个程序员��g��都要先成为领域专�Ӟ��然后成�ؓ领域分类学专�Ӟ��然后构造一个完整的�l�承树，然后才能new出对象，让程序跑��h��。正是因��个过�E�太漫长�Q�太困难�Q�再加上C++本��n的复杂度��很大，所以C++出现�q�么多年�Q�真正堪�U�经典的面向对象�c�d��和框�Ӟ��几乎屈指可数。很多流行的库，比如MFC、iostream�Q�都暴露��Z��问题。一般程序员总觉得是自己的水�q�不够，于是下更大功夫去�l�剑。殊不知�Ҏ(gu��)��上是方向错了�Q�脱��M��对象范式的本质，企图用静态分�c�L��来对现实世界建模�Q�去�ȝ��变化万千的动态世界。这么难的事�Q�你水��^再高也很隑ց�好�?/p>

可以从一个具体的例子来理解这个道理，比如在一个GUI�pȝ��里，一�?Push Button 的设计问题。事实上在一个实际的�E�序里，一�?push button 到底“是不�?#8221;一�?button�Q�进而是不是一�?window/widget�Q��ƈ不重要，本质上我�Ҏ(gu��)��不关心它是什么，它从属于哪一个类�Q�在�l�承树里处于什么位�|�，只要那里有这么一个东西，我可以点它，点完了可以发生相应的效果�Q�就可以了。可是Simula –> C++ 所鼓励的面向对象设计风��|��非要上来��想清楚�Q�a Push Button is-a Button, a Button is-a Command-Target Control, a Command-Target Control is-a Control, a Control is-a Window. 把这一圈都想透彻之后�Q�才�?new 一�?Push Button�Q�然后才能让它工作。这��Ş而上学了�Q�这��p��d��际了。所以很隑ց�好。你看到 MFC 的类�l�承树，觉得设计者太牛了�Q�能把这些层�ơ概念都��x��楚，自己的水�q��不够�Q�还得修点{��实际上呢，�q�个设计是经�q�数不清的失败和��q��出来、砸出来的，MFC的前�w?Afx 不是��失败了吗？1995�q�还有一个叫�?Taligent 的大��目�Q�召集了包括 Eric Gamma 在内的一大堆牛�h�Q�要用C++做一个一�l�天下的application framework�Q�最后也以惨败告�l�，�q�公叔R��倒闭了，CEO车祸�w�亡�Q�牛��Z��(zh��n)�数遣散。附带说一下，�q�个Taligent��目是�ؓ了跟NextSTEP和Microsoft Cairo竞争�Q�前者用Objective-C�~�写�Q�后来发展�ؓCocoa�Q�后者用传统的Win32 + COM作�ؓ基础架构�Q�后来发展�ؓWindows NT。而Objective-C和COM�Q�恰恰就在动态消息分�z�方面，与C++�q�然不同。后面还会谈到�?/p>

客观地说�Q?#8220;面向�cȝ��设计”�q�不是没有意义。来源于实践又高于实�늚�抽象和概念，往往能更有力地把握住现实世界的本质，比如MVC架构�Q�就是这��L��有力的抽象。但是这�U�抽象，应该是来源于长期最佛_��늚��ȝ��和提高，而不是面寚w��题时主要的解��x��\。过于强调这�U�抽象，无异于假定程序员各个都是哲学�Ӟ��h��对现实世界准��而深�ȝ��抽象能力�Q�当然是不符合实际情�늚�。结果呢�Q�刚学习面向对象没几天的�E�序员，对眼前鲜�zȝ��对象世界视而不见，一个个都煞有介事地��L��哲学冥想�Q�企图越�q�现实世界，��L��象出其背后本质，当然败得很惨�?/p>

其实C++问世之后不久�Q�这个问题就暴露出来了。第一个C++�~�译�?Cfront 1.0 是单�l�承�Q�而到�?Cfront 2.0�Q�加入了多��ѝ��ؓ什么？��是因�ؓ使用中�h们发现逻辑上似乎完��的静态单�l�承关系�Q�碰到复杂灵�zȝ��现实世界�Q�就破熾癑և�——蝙蝠是鸟也是兽�Q�水上飞��飞也能游�Q�它们该如何归类呢？本来�q�应该促使大家反思��承这个机制本�w�，但是那个时候全世界陷入�l�承狂热�Q�于是就开始给�l�承打补丁，加入多��承，�q�而加入虚�l�承�Q�。到了虚�l�承�Q�明��g�h一看便知，�q�只是一个语法补丁，是�ؓ了逃避职责而制造的一块无用的遮羞布，它已�l�完全已�l�脱��d��践了——有谁在事前能够判断是否应该对基�c�进行虚�l�承呢？

��C��1990�q�代中期�Q�问题已�l�十分明显。UML中有一个对象活动图�Q�其描述的就是运行时对象之间�怺�传递消息的模型�?994�q�Robert C. Martin在《Object-Oriented C++ Design Using Booch Method》中�Q�曾��面向对象设计从对象活动图入手�Q�而不是从�c�d��入手。�?995�q�出版的�l�典作品《Design Patterns》中�Q�徏议优先考虑�l�合而不是��承，�q�也是尽人皆知的事情。这些迹象表明，在那个时候，面向对象�C�֌�里的思想领袖们，已经意识�?#8220;面向�cȝ��设计”�q�不好用。只可惜他们的革命精��还不够�?/p>

7. 你可能要问，Java �?NET也是用��承关�pȝ��l�类库，�q�进行设计的啊，怎么那么成功呢？�q�里有三点应该注意。第一�Q�C++的难不仅仅在于其静态结构体�p�，�q�有很多源于语言设计上的包袱�Q�比如对C的兼容，比如没有垃圾攉��机制�Q�比如对效率的强调，�{�等。一旦把�q�些包袱丢掉�Q�设计的隑ֺ��实可以大大下降。第二，Java�?NET的核心类库是在C++十几�q�成功和��p�|的经验教训基��之上�Q�结合COM体系优点设计实现的，自然要好上一大块。事实上�Q�在Java�?NET核心�c�d��的设计中很多地方�Q�体现的是基于接口的设计�Q�和真正的基于对象的设计。有了这两个主角站台�Q?#8220;面向�cȝ��设计”不能喧宾��Z��Q�也能发挥一些好的作用。第三，如后文指出，Java�?NET中分别对C++最大的问题——缺��对象��别的delegate机制做出了自��q��回应�Q�这��大大��I补了原来的问题�?/p>

��管如此�Q�Java�q�是沾染上了“面向�c�设�?#8221;的癌症，基础�c�d��里就有很多架床叠屋的设计�Q�而J2EE/Java EE当中�Q�这�U��Ş而上学的设计也很普遍�Q�所以也引发了好几次轻量化的�q�动。这斚w��我�ƈ不是太懂�Q�可能需要真正的Java高手出来现��n说法。我对Java的看法以前就讲过——��^台和语言核心非常好，但风气不好，崇尚华丽�J�复的设计，装牛逼的人太多�?/p>

至于.NET�Q�我听陈榕介�l�过�Q�在设计.NET的时候，微��Y内部对于是否允许�l�承爆发了非常激烈的争论。很多资深高人都强烈反对�l�承。至于最后引入��承，很大�E�度上是营销需要压倒了技术理性。尽��如此，�׃��有COM的基��Q�又实现了非常彻底的delegate�Q�所�?.NET 的设计水�q��是很高的。它的主要问题不在这�Q�在于太急于求胜�Q�更新速度太快�Q�基��不牢。当�Ӟ��Ҏ(gu��)��问题�q�是微��Y没有能够在Web和Mobile领域里占到多大的优势�Q�也��׃��?NET没有用武之地�?/p>

8. COM。COM的要义是�Q��Y件是由COM Components�l�成�Q�components之间彼此通过接口�怺�通讯。这是否让你回想��h��文开��所提出的对象范型的两个基本原则�Q�有��的是，在COM的术语里�Q?#8220;COM Component ” �?#8220;object ”通假�Q�这��׃��COM的心思昭然若揭了。Don Box在Essential COM里开��就��_��COM是更好的C++�Q�事实上��是告诉大家�Q��Ş而上学的“面向�c�设�?#8221;不好使，�q�是回到对象吧�?/p>

用COM开发的时候，一个组�?#8220;是什�?#8221;不重要，它具有什么接口，也就是说�Q�能够对它发什么消息，才是重要的。你可以用IUnknown::QueryInterface问组件能对哪一�l�消息作出反应。向�l��g分派消息也不一定要被绑定在�Ҏ(gu��)��调用上，如果实现�?IDispatch�Q�还可以实现“自动�?#8221;调用�Q�也��是COM术语里的 Automation�Q�而通过列集�Q�mashal�Q�，可以跨进�E�、跨�|�络向另一�l��g发送消息，通过 moniker�Q�可以在分布式系�l�里定位和发现组件。如果你��q��“对象——消�?#8221;的观念去看COM的设计，��׃��意识刎ͼ�整个COM体系��是用规范如何做对象�Q�如何发消息的。或者更直白一点，COM��是用C/C++��是模拟��Z��个Smalltalk。而且COM的概念世界里没有�l�承�Q�就其纯�z�性而言�Q�比Smalltalk�q�Smalltalk。在对象泛型上，COM辑ֈ�了一个高峎ͼ�领先于那个时代，甚至于比它的�l��Q.NET�q�要�U�洁�?/p>

COM的主要问题是它的学习隑ֺ�和安全问题，而且�Q�它�q�于�q�求�U�洁性，完全攑ּ��?#8220;面向�c�设�?#8221; 的机�Ӟ��昑־�有点�q��?/p>

9. 好像有点扯远了，其实�q�是在说正事。上面说到由于C++的静态消息机�Ӟ��D��了�Ş而上学的“面向�cȝ��设计”�Q�祸��x��I��但实际上，C++是有一个补救机会的�Q�那��是实现对象�U�别的delegate机制。学�q?NET的�h�Q�一听delegate�q�个词就知道是什么意思，但Java里没有对应机制。在C++的术语体�p�里�Q�所谓对象��别delegate�Q�就是一个对象回调机制。通过delegate�Q�一个对象A可以把一个特定工作，比如处理用户的鼠标事�Ӟ��委托�l�另一个对象B的一个方法来完成。A不必知道B的名字，也不用知道它的类型，甚至都不需要知道B的存在，只要求B对象��h��一个签名正��的�Ҏ(gu��)��Q�就可以通过delegate把工作交�l�B的这个方法来执行。在C语言里，�q�个机制是通过函数指针实现的，所以很自然的，在C++里，我们希望通过指向成员函数的指针来解决�c�M��问题�?/p>

然而就在这个问题上�Q�C++让�h��D��痛惜�?/p>

zhaoyg 2011-01-20 22:24 发表评论

zhaoyg — Sat, 08 May 2010 08:21:00 GMT

前一�D�|��间写了类��g��q�样的一�D�代�?br>

class A
{
private:
    int *const ptr;
public:
    A():ptr(NULL)
    {
    }
};

A one;
A two;
two = one;

�~�译时发玎ͼ��~�译器提�C��默认赋值操作符不能用，而当我去掉ptr成员的const关键字后�Q�便好了。当时很�U�闷�q�是怎么搞的�?br>后来在好心�h的帮助下�Q�才意识到ptr是个const�Q�所以默认的赋值操作符不能对ptr�q�行赋倹{�?br>
唉，当时知道是这个原因后真的是羞涩难当，自己明知道const不能被赋值是常识问题�Q�但当时却死�z�L��能找出原因�?br>而更要�h命的是我之前�?a href="http://m.shnenglu.com/zhaoyg/archive/2009/10/07/98041.html">{偶尔学习C++标准} �?[对象的复�?- 复制构造与赋值操作符] 中就已经对赋值操作符做了一些笔讎ͼ�但我竟然把一些内容给忘了�Q�也可能是压根就没注意）�?br>
现在重新��p��动合成的赋值操作符何时不能使用再单独做一�ơ笔记�?br>
当类中拥有以下一�U�或几种情况�Ӟ��隐式定义的赋值操作符是不能��用的�Q?br>1.非静态的const成员变量
2.非静态的引用�c�d��成员变量
3.非静态的�cȝ��型的成员变量的赋值操作符不可讉K��
4.�Q�如果有�Q�基�c�M��的赋值操作符不可讉K��

注，对于拥有以上情况中的一�U�或多种的类�Q�标准中的用词是�Q�ill-formed。我不知道�ؓ什么要用ill-formed�Q�字面意思：不规范）�Q�但不管怎样�Q�对于ill-formed�Q�编译器的行为就是，无法�~�译通过�?br>
后记�Q�希望这�ơ不要再忘记�q�些内容了�?

zhaoyg 2010-05-08 16:21 发表评论

zhaoyg — Thu, 29 Apr 2010 15:01:00 GMT

今天�Q�我无意中将鼠标攑֜�一个在�c�M��定义的枚举成员后�Q�弹��Z��一个含有该成员原型的提�C�Z��息，看到�q�个提示后我��时愣住�?..
如图�Q?br>

当时看到__unnamed_0000_1直接愣住了，哪来的__unnamed_0000_1�Q?br>正当我想问别人的时候，�H�然惛_��了答案，原来�{�案很简单。因为TET是enum的一个成员，既然是成员，那么必然有一个作用域了，而我定义的是匿名的枚举，所以编译器��׃��__unnamed_0000_1来命名了�?

zhaoyg 2010-04-29 23:01 发表评论

[转] 再次�U�结于友元声明是否向外围引入名字

zhaoyg — Sun, 07 Mar 2010 02:49:00 GMT

C++标准�Q?

3. A function first declared in a friend declaration hasexternal linkage (3.5). Otherwise, the function retains its previous linkage (7.1.1).

按照3中说的，下面代码是应该通过�?

class X
{
friend void f();
};

int main()
{
f(); //因�ؓ�c�X中的友元函数f的声明有外部链接�Q�所以，f可见
}
void f() { /* ok to define friend function in the class body */ }

�~�译��试�Q?
VC2005/2010通过 �Q�而GCC 4.4.3报错�Q�无法找到名字f

5. A function can be defined in a friend declaration of a class if and only if the class is a non-local class (9.8),the function name is unqualified, and the function has namespace scope.
[Example:
class M {
friend void f() { } // definition of global f, a friend of M,
// not the definition of a member function
};
—end example]
Such a function is implicitly inline. A friend function defined in a class is in the (lexical) scope of the class in which it is defined. A friend function defined outside the class is not (3.4.1).

按照5中说的，既然在类中定义友元函数f�Q�是"definition of global f"�Q�那么也��可以理解�ؓ下面的代码是可以通过�~�译�?

class X
{
friend void f(){ /* ok to define friend function in the class body */ }
};

int main()
{
f();
}

然而VC2005/2010和GCC4.4.3都不能通过

TCPL中对友元有如下说明：
“一个友元声明不会给外围的作用域引进一个名字”�?
“一个友元函数或者需要在某个外围作用域里昑ּ�声明�Q�或者以它的�c�L��p��c�L��生的�c�M��Z��个参�?13�Q?�?�Q�否则就无法调用�q�个友元了。�?

C++ primer有如下：
“友元声明将已命名的�c�L��非成员函数引入到外围作用域中。此外，友元函数可以在类的内部定义，该函数的作用域扩展到包围该类定义的作用域。”�?
“用友元引入的类名和函数�Q�定义或声明�Q�，可以像预先声明的一样��用�?
C++ primer中的例子�Q?
class X {
friend class Y;
friend void f() { /* ok to define friend function in the class body */ }
};
class Z {
Y *ymem; // ok: declaration for class Y introduced by friend in X
void g() { return ::f(); } // ok: declaration of f introduced by X
};

标准中说的和C++ PRIMER一��P��而和TCPL不一栗��?
至于�~�译器，GCC做的和TCPL说的一��P��而VC和标准说的部分一��P��对于在友元声明出定义函数处有出入�Q?

个�h�ȝ��
两个�~�译器行��Z��同，所以尽量提前声明友元所声明的名�?

以上只是个�h的看法，如果有不对的地方�Q?span style="COLOR: #ff0000">恌��各位大大指正

zhaoyg 2010-03-07 10:49 发表评论

zhaoyg — Thu, 11 Feb 2010 10:53:00 GMT

对象如果要安全的自杀�Q�得保证以下条�g�Q?nbsp;

this对象是必��ȝ�� new操作�W�分�?而不是用new[]�Q�也不是用placement new�Q�也不是局部对象，也不是global对象)�?
delete this后，不能讉K��该对象�Q何的成员变量及虚函数(delete this回收的是数据�Q�这包括对象的数据成员以及vtable�Q�不包括函数代码)�?nbsp;
delete this后，不能再访问this指针。换句话��_��你不能去��查它、将它和其他指针比较、和 NULL比较、打印它、�{换它�Q�以及其它的��M��事情�?

zhaoyg 2010-02-11 18:53 发表评论

对右值类的一点小认识

zhaoyg — Wed, 10 Feb 2010 13:35:00 GMT

class T{ /**/ };

T fun(){  return T();  }

int main()
{
    fun() = T();
    return 0;
}

当我看到上面�q�样的代码时�Q�我便认��个代码无法编译通过的，因�ؓ按我所知道的，函数fun所�q�回的是一个��时对象，而��时对象是不能被修改的�Q�然而fun()=T()语句便恰恰是在对临时对象�q�行修改。但是当我编译之后却�ȝ��了，居然通过了，我很�U�闷�?br>后来在网友的帮助下，在标准中扑ֈ�了答案：

3.10.5
The result of calling a function that does not return a reference is an rvalue. User defined operators are functions, and whether such operators expect or yield lvalues is determined by their parameter and return types.

13.5.7
The identities among certain predefined operators applied to basic types (for example, ++a ≡ a+=1) need not hold for operator functions. Some predefined operators, such as +=, require an operand to be an lvalue when applied to basic types; this is not required by operator functions.

3.10
An lvalue for an object is necessary in order to modify the object except that an rvalue of class type can also be used to modify its referent under certain circumstances. [Example: a member function called for an object (9.3) can modify the object. ]

也就是说�Q�在对内�|�类型进行赋值操作时�Q�将调用内置的赋值操作符�Q�而这�U�内�|�的要求左操作数必须是左��|��而当对类�c�d��对象�q�行赋值时�Q�所调用的是重蝲的赋值操作符�Q�但重蝲的操作符�q�没有要求必��M��用左��|��也就是说�Q�赋值操作符的左操作数可以是叛_��{�?br>后来得知�Q�在C++中右值可以是一个对象，�?#8220;对象”��指的是“一�D�内存存贮区�?#8221;�Q�但C中的叛_��则不是一个对象，他只是一个倹{�?br>
以上内容如有不对之处�Q�还望不惜指正�?br>
对lvalue和rvalue的较详细介绍��L��文章<Lvalues and Rvalues>�Q?a href="http://m.shnenglu.com/zhaoyg/archive/2010/02/06/107405.html">http://m.shnenglu.com/zhaoyg/archive/2010/02/06/107405.html

zhaoyg 2010-02-10 21:35 发表评论

[转] Lvalues and Rvalues

zhaoyg — Sat, 06 Feb 2010 14:41:00 GMT

C and C++ enforce subtle differences on the expressions to the left and right of the assignment operator

If you've been programming in either C or C++ for a while, it's likely that you've heard the terms lvalue (pronounced "ELL-value") and rvalue (pronounced "AR-value"), if only because they occasionally appear in compiler error messages. There's also a good chance that you have only a vague understanding of what they are. If so, it's not your fault.

Most books on C or C++ do not explain lvalues and rvalues very well. (I looked in a dozen books and couldn't find one explanation I liked.) This may be due to of the lack of a consistent definition even among the language standards. The 1999 C Standard defines lvalue differently from the 1989 C Standard, and each of those definitions is different from the one in the C++ Standard. And none of the standards is clear.

Given the disparity in the definitions for lvalue and rvalue among the language standards, I'm not prepared to offer precise definitions. However, I can explain the underlying concepts common to the standards.

As is often the case with discussions of esoteric language concepts, it's reasonable for you to ask why you should care. Admittedly, if you program only in C, you can get by without understanding what lvalues and rvalues really are. Many programmers do. But understanding lvalues and rvalues provides valuable insights into the behavior of built-in operators and the code compilers generate to execute those operators. If you program in C++, understanding the built-in operators is essential background for writing well-behaved overloaded operators.

Basic concepts
--------------------------------------------------------------------------------

Kernighan and Ritchie coined the term lvalue to distinguish certain expressions from others. In The C Programming Language (Prentice-Hall, 1988), they wrote "An object is a manipulatable region of storage; an lvalue is an expression referring to an object....The name 'lvalue' comes from the assignment expression E1 = E2 in which the left operand E1 must be an lvalue expression."

In other words, the left and right operands of an assignment expression are themselves expressions. For the assignment to be valid, the left operand must refer to an object-it must be an lvalue. The right operand can be any expression. It need not be an lvalue. For example:

int n;

declares n as an object of type int. When you use n in an assignment expression such as:

n = 3;

n is an expression (a subexpression of the assignment expression) referring to an int object. The expression n is an lvalue.

Suppose you switch the left and right operands around:

3 = n;

Unless you're a former Fortran programmer, this is obviously a silly thing to do. The assignment is trying to change the value of an integer constant. Fortunately, C and C++ compilers reject it as an error. The basis for the rejection is that, although the assignment's left operand 3 is an expression, it's not an lvalue. It's an rvalue. It doesn't refer to an object; it just represents a value.

I don't know where the term rvalue comes from. Neither edition of the C Standard uses it, other than in a footnote stating "What is sometimes called 'rvalue' is in this standard described as the 'value of an expression.'"

The C++ Standard does use the term rvalue, defining it indirectly with this sentence: "Every expression is either an lvalue or an rvalue." So an rvalue is any expression that is not an lvalue.

Numeric literals, such as 3 and 3.14159, are rvalues. So are character literals, such as 'a'. An identifier that refers to an object is an lvalue, but an identifier that names an enumeration constant is an rvalue. For example:

enum color { red, green, blue };
color c;
...
c = green; // ok
blue = green; // error

The second assignment is an error because blue is an rvalue.

Although you can't use an rvalue as an lvalue, you can use an lvalue as an rvalue. For example, given:

int m, n;

you can assign the value in n to the object designated by m using:

m = n;

This assignment uses the lvalue expression n as an rvalue. Strictly speaking, a compiler performs what the C++ Standard calls an lvalue-to-rvalue conversion to obtain the value stored in the object to which n refers.

Lvalues in other expressions
-------------------------------------------------------------------------------

Although lvalues and rvalues got their names from their roles in assignment expressions, the concepts apply in all expressions, even those involving other built-in operators.

For example, both operands of the built-in binary operator + must be expressions. Obviously, those expressions must have suitable types. After conversions, both expressions must have the same arithmetic type, or one expression must have a pointer type and the other must have an integer type. But either operand can be either an lvalue or an rvalue. Thus, both x + 2 and 2 + x are valid expressions.

Although the operands of a binary + operator may be lvalues, the result is always an rvalue. For example, given integer objects m and n:

m + 1 = n;

is an error. The + operator has higher precedence than the = operator. Thus, the assignment expression is equivalent to:

(m + 1) = n; // error

which is an error because m + 1 is an rvalue.

As another example, the unary & (address-of) operator requires an lvalue as its operand. That is, &n is a valid expression only if n is an lvalue. Thus, an expression such as &3 is an error. Again, 3 does not refer to an object, so it's not addressable.

Although the unary & requires an lvalue as its operand, it's result is an rvalue. For example:

int n, *p;
...
p = &n; // ok
&n = p; // error: &n is an rvalue

In contrast to unary &, unary * produces an lvalue as its result. A non-null pointer p always points to an object, so *p is an lvalue. For example:

int a[N];
int *p = a;
...
*p = 3; // ok

Although the result is an lvalue, the operand can be an rvalue, as in:

*(p + 1) = 4; // ok

Data storage for rvalues
--------------------------------------------------------------------------------

Conceptually, an rvalue is just a value; it doesn't refer to an object. In practice, it's not that an rvalue can't refer to an object. It's just that an rvalue doesn't necessarily refer to an object. Therefore, both C and C++ insist that you program as if rvalues don't refer to objects.

The assumption that rvalues do not refer to objects gives C and C++ compilers considerable freedom in generating code for rvalue expressions. Consider an assignment such as:

n = 1;

where n is an int. A compiler might generate named data storage initialized with the value 1, as if 1 were an lvalue. It would then generate code to copy from that initialized storage to the storage allocated for n. In assembly language, this might look like:

one: .word 1
...
mov (one), n

Many machines provide instructions with immediate operand addressing, in which the source operand can be part of the instruction rather than separate data. In assembly, this might look like:

mov #1, n

In this case, the rvalue 1 never appears as an object in the data space. Rather, it appears as part of an instruction in the code space.

On some machines, the fastest way to put the value 1 into an object is to clear it and then increment it, as in:

clr n
inc n

Clearing the object sets it to zero. Incrementing adds one. Yet data representing the values 0 and 1 appear nowhere in the object code.

More to come
--------------------------------------------------------------------------------

Although it's true that rvalues in C do not refer to objects, it's not so in C++. In C++, rvalues of a class type do refer to objects, but they still aren't lvalues. Thus, everything I've said thus far about rvalues is true as long as we're not dealing with rvalues of a class type.

Although lvalues do designate objects, not all lvalues can appear as the left operand of an assignment. I'll pick up with this in my next column.

如下�Q?/p>

--------------------------------------------------------------------------------
Non-modifiable Lvalues

--------------------------------------------------------------------------------

Lvalues actually come in a variety of flavors. If you really want to understand how compilers evaluate expressions, you'd better develop a taste.

const 限定�W�的含义�Q?比如 int const m;
它�ƈ不是说m的��g��能被修改, 而是�?m 不能修改它引用的对象�Q?br>e.g:
int m;
int const *p = &m;
m += 1; //right
*p += 1; //wrong

An expression is a sequence of operators and operands that specifies a computation. That computation might produce a resulting value and it might generate side effects. An assignment expression has the form:

e1 = e2

where e1 and e2 are themselves expressions. The right operand e2 can be any expression, but the left operand e1 must be an lvalue expression. That is, it must be an expression that refers to an object. As I explained last month ("Lvalues and Rvalues," June 2001, p. 70), the "l" in lvalue stands for "left," as in "the left side of an assignment expression." For example:

int n;

declares n as an object of type int. When you use n in an assignment expression such as:

n = 3;

the n is an expression (a subexpression of the assignment expression) referring to an int object. The expression n is an lvalue. On the other hand:

3 = n;

causes a compilation error, and well it should, because it's trying to change the value of an integer constant. Although the assignment's left operand 3 is an expression, it's not an lvalue. It's an rvalue. An rvalue is simply any expression that is not an lvalue. It doesn't refer to an object; it just represents a value.

Although lvalue gets its name from the kind of expression that must appear to the left of an assignment operator, that's not really how Kernighan and Ritchie defined it. In the first edition of The C Programming Language (Prentice-Hall, 1978), they defined an lvalue as "an expression referring to an object." At that time, the set of expressions referring to objects was exactly the same as the set of expressions eligible to appear to the left of an assignment operator. But that was before the const qualifier became part of C and C++.

The const qualifier renders the basic notion of lvalues inadequate to describe the semantics of expressions. We need to be able to distinguish between different kinds of lvalues. And that's what I'm about to show you how to do. But first, let me recap.

A few key points
--------------------------------------------------------------------------------

The assignment operator is not the only operator that requires an lvalue as an operand. The unary & (address-of) operator requires an lvalue as its sole operand. That is, &n is a valid expression only if n is an lvalue. Thus, an expression such as &3 is an error. The literal 3 does not refer to an object, so it's not addressable.

Not only is every operand either an lvalue or an rvalue, but every operator yields either an lvalue or an rvalue as its result. For example, the binary + operator yields an rvalue. Given integer objects m and n:

m + 1 = n;

is an error. The + operator has higher precedence than the = operator. Thus, the assignment expression is equivalent to:

(m + 1) = n; // error

which is an error because m + 1 is an rvalue.

An operator may require an lvalue operand, yet yield an rvalue result. The unary & is one such operator. For example:

int n, *p;
...
p = &n; // ok
&n = p; // error: &n is an rvalue

On the other hand, an operator may accept an rvalue operand, yet yield an lvalue result, as is the case with the unary * operator. A valid, non-null pointer p always points to an object, so *p is an lvalue. For example:

int a[N];
int *p = a;
...
*p = 3; // ok

Although the result is an lvalue, the operand can be an rvalue, as in:

*(p + 1) = 4; // ok

With this in mind, let's look at how the const qualifier complicates the notion of lvalues.

Lvalues and the const qualifier
--------------------------------------------------------------------------------

A const qualifier appearing in a declaration modifies the type in that declaration, or some portion thereof. For example: int const n = 127;

declares n as object of type "const int." The expression n refers to an object, almost as if const weren't there, except that n refers to an object the program can't modify. For example, an assignment such as:

n = 0; // error, can't modify n

produces a compile-time error, as does:

++n; // error, can't modify n

(I covered the const qualifier in depth in several of my earlier columns. See "Placing const in Declarations," June 1998, p. 19 or "const T vs. T const," February 1999, p. 13, among others.) How is an expression referring to a const object such as n any different from an rvalue? After all, if you rewrite each of the previous two expressions with an integer literal in place of n, as in:

7 = 0; // error, can't modify literal ++7; // error, can't modify literal

they're both still errors. You can't modify n any more than you can an rvalue, so why not just say n is an rvalue, too? The difference is that you can take the address of a const object, but you can't take the address of an integer literal. For example:

int const *p;
...
p = &n; // ok
p = &7; // error

Notice that p declared just above must be a "pointer to const int." If you omitted const from the pointer type, as in:

int *p;

then the assignment:

p = &n; // error, invalid conversion

would be an error. When you take the address of a const int object, you get a value of type "pointer to const int," which you cannot convert to "pointer to int" unless you use a cast, as in:

p = (int *)&n; // (barely) ok

Although the cast makes the compiler stop complaining about the conversion, it's still a hazardous thing to do. (See "What const Really Means," August 1998, p. 11.)

Thus, an expression that refers to a const object is indeed an lvalue, not an rvalue. However, it's a special kind of lvalue called a non-modifiable lvalue-an lvalue that you can't use to modify the object to which it refers. This is in contrast to a modifiable lvalue, which you can use to modify the object to which it refers.

Once you factor in the const qualifier, it's no longer accurate to say that the left operand of an assignment must be an lvalue. Rather, it must be a non-modifiable lvalue. In fact, every arithmetic assignment operator, such as += and *=, requires a modifiable lvalue as its left operand. For all scalar types:

x += y; // arithmetic assignment

is equivalent to:

x = x + y; // assignment

except that it evaluates x only once. Since the x in this assignment must be a modifiable lvalue, it must also be a modifiable lvalue in the arithmetic assignment. Not every operator that requires an lvalue operand requires a modifiable lvalue. The unary & operator accepts either a modifiable or a non-modifiable lvalue as its operand. For example, given:

int m;
int const n = 10;

&m is a valid expression returning a result of type "pointer to int," and &n is a valid expression returning a result of type "pointer to const int."

What it is that's really non-modifiable
--------------------------------------------------------------------------------
Earlier, I said a non-modifiable lvalue is an lvalue that you can't use to modify an object. Notice that I did not say a non-modifiable lvalue refers to an object that you can't modify-I said you can't use the lvalue to modify the object. The distinction is subtle but nonetheless important, as shown in the following example. Consider:

int n = 0;
int const *p;
...
p = &n;

At this point, p points to n, so *p and n are two different expressions referring to the same object. However, *p and n have different types. As I explained in an earlier column ("What const Really Means"), this assignment uses a qualification conversion to convert a value of type "pointer to int" into a value of type "pointer to const int." Expression n has type "(non-const) int." It is a modifiable lvalue. Thus, you can use n to modify the object it designates, as in:

n += 2;

On the other hand, p has type "pointer to const int," so *p has type "const int." Expression *p is a non-modifiable lvalue. You cannot use *p to modify the object n, as in:

*p += 2;

even though you can use expression n to do it. Such are the semantics of const in C and C++.

In summary
--------------------------------------------------------------------------------
Every expression in C and C++ is either an lvalue or an rvalue. An lvalue is an expression that designates (refers to) an object. Every lvalue is, in turn, either modifiable or non-modifiable. An rvalue is any expression that isn't an lvalue. Operationally, the difference among these kinds of expressions is this:

A modifiable lvalue is addressable (can be the operand of unary &) and assignable (can be the left operand of =).
A non-modifiable lvalue is addressable, but not assignable.
An rvalue is neither addressable nor assignable.
Again, as I cautioned last month, all this applies only to rvalues of a non-class type. Classes in C++ mess up these concepts even further.

Dan Saks is a high school track coach and the president of Saks & Associates, a C/C++ training and consulting company. You can write to him at dsaks@wittenberg.edu.

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/SeeSeaBee/archive/2007/09/08/1777120.aspx

zhaoyg 2010-02-06 22:41 发表评论

zhaoyg — Sun, 15 Nov 2009 06:25:00 GMT

作者：荣耀
原文出处�Q?a target=_blank>http://www.royaloo.com/articles/articles_2003/Metaprogramming.htm

摘要

本文描述了模板元�~�程技术的��h��、概念和机制�Q��ƈ介绍了模板元�~�程技术在Blitz++和Loki�E�序库中的应用�?nbsp;

关键�?/strong>

�~�译期计��?nbsp; 模板元编�E?nbsp; Blitz++ Loki

��D��

1994�q�_��C++标准委员会在圣�P哥�D行的一�ơ会议期间Erwin Unruh展示了一�D�可以��生质数的代码。这�D�代码的特别之处在于质数产生于编译期而非�q�行期，在编译器产生的一�p�d��错误信息中间�Ҏ(gu��)��着�?到某个设定��g��间的所有质敎ͼ�

// Prime number computation by Erwin Unruh
template struct D { D(void*); operator int(); };

template struct is_prime {
    enum { prim = (p%i) && is_prime<(i > 2 ? p : 0), i -1> :: prim };
};

template < int i > struct Prime_print {
    Prime_print a;
    enum { prim = is_prime::prim };
    void f() { D d = prim; }
};

struct is_prime<0,0> { enum {prim=1}; };
struct is_prime<0,1> { enum {prim=1}; };
struct Prime_print<2> { enum {prim = 1}; void f() { D<2> d = prim; } };
#ifndef LAST
#define LAST 10
#endif
main () {
    Prime_print a;
}

�c�L��板D只有一个参��Cؓvoid*的构造器�Q�而只�?才能被合法�{换�ؓvoid*�?994�q�_��Erwin Unruh采用Metaware �~�译器编译出错信息如下（以及其它一些信息，��短�v见，它们被删除了�Q�：
| Type `enum{}′ can′t be converted to txpe `D<2>′ ("primes.cpp",L2/C25).
| Type `enum{}′ can′t be converted to txpe `D<3>′ ("primes.cpp",L2/C25).
| Type `enum{}′ can′t be converted to txpe `D<5>′ ("primes.cpp",L2/C25).
| Type `enum{}′ can′t be converted to txpe `D<7>′ ("primes.cpp",L2/C25).
如今�Q�上面的代码已经不再是合法的C++�E�序了。以下是Erwin Unruh亲手�l�出的修订版�Q�可以在今天�W�合标准的C++�~�译器上�q�行�~�译�Q?br>
// Prime number computation by Erwin Unruh

template struct D { D(void*); operator int(); };

template struct is_prime {
    enum { prim = (p==2) || (p%i) && is_prime<(i>2?p:0), i-1> :: prim };
};

template struct Prime_print {
Prime_print a;
    enum { prim = is_prime::prim };
    void f() { D d = prim ? 1 : 0; a.f();}
};

template<> struct is_prime<0,0> { enum {prim=1}; };
template<> struct is_prime<0,1> { enum {prim=1}; };

template<> struct Prime_print<1> {
    enum {prim=0};
    void f() { D<1> d = prim ? 1 : 0; };
};

#ifndef LAST
#define LAST 18
#endif

main() {
    Prime_print a;
    a.f();
}
在GNU C++ (MinGW Special) 3.2中编译这�D늨�序时�Q�编译器��会�l�出如下出错信息�Q�以及其它一些信息，��短�v见，它们被删除了�Q�：
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 17]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 13]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 11]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 7]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 5]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 3]'
Unruh.cpp:12: initializing argument 1 of `D::D(void*) [with int i = 2]'
�q�个例子展示了可以利用模板实例化机制于编译期执行一些计��。这�U�通过模板实例化而执行的�~�译期计��技术即被称为模板元�~�程�?nbsp;

一个可以运行的模板元编�E�例�?/strong>

模板元编�E�（Template Metaprogramming�Q�更准确的含义应该是“�~?#8216;可以�~�程序的’�E�序”�Q�而模板元�E�序�Q�Template Metaprogram�Q�则�?#8220;‘可以�~�程序的’�E�序”。也��是��_��我们�l�出代码的��生规则，�~�译器在�~�译期解释这些规则�ƈ生成��C��码来实现我们预期的功能�?nbsp;
Erwin Unruh的那�D늻��总�码�ƈ没有执行�Q�它只是以编译出错信息的方式输出中间计算�l�果。让我们来看一个可以运行的模板元编�E�例�?�?计算�l�定整数的指定次方：

// xy.h

//原始摸板
template
class XY
{
public:
    enum { result_ = Base * XY::result_ };
};

//用于�l�结递归的局部特化版
template
class XY
{
public:
    enum { result_ = 1 };
};
模板元编�E�技术之�Ҏ(gu��)��在于递归模板实例化。第一个模板实��C��一般情况下的递归规则。当用一�Ҏ(gu��)��?lt;X, Y>来实例化模板�Ӟ��模板XY需要计��其result_的��|��同一模板中针�?lt;X, Y-1>实例化所得结果乘以X卛_��。第二个模板是一个局部特化版本，用于�l�结递归�?nbsp;
让我们看看��用此模板来计��?^4 �Q�通过实例化XY<5, 4>�Q�时发生了什么：
// xytest.cpp

#include
#include "xy.h"

int main()
{
    std::cout << "X^Y<5, 4>::result_ = " << XY<5, 4>::result_;
}
首先�Q�编译器实例化XY<5, 4>�Q�它的result_�? * XY<5, 3>::result_�Q�如此一来，又需要针�?lt;5, 3>实例化同��L��模板�Q�后者又实例化XY<5, 2>…… 当实例化到XY<5, 0>的时候，result_的��D��计算�?�Q�至此递归�l�束�?nbsp;

递归模板实例化的深度和终�l�条�?/strong>

可以惌��Q�如果我们以非常大的Y值来实例化类模板XY�Q�那肯定会占用大量的�~�译器资源甚至会�q�速耗尽可用资源�Q�在计算�l�果溢出之前�Q�，因此�Q�在实践中我们应该有节制��C��用模板元�~�程技术�?nbsp;
虽然 C++标准��的最��实例化深度只有17层，然而大多数�~�译器都能够处理臛_��几十层，有些�~�译器允许实例化��x��癑ֱ��Q�更有一些可达数千层�Q�直臌��源耗尽�?nbsp;
假如我们拿掉XY模板局部特化版本，情况会如何？
// xy2.h

//原始摸板
template
class XY
{
public:
    enum { result_ = Base * XY::result_ };
};
��试�E�序不变�Q?nbsp;
// xytest2.cpp

#include
#include "xy2.h"

int main()
{
    std::cout << "X^Y<5, 4>::result_ = " << XY<5, 4>::result_;
}
执行如下�~�译命��o�Q?nbsp;
C:\>g++ -c xytest2.cpp
你将会看到递归实例化将一直进行下去，直到辑ֈ��~�译器的极限�?nbsp;
GNU C++ (MinGW Special) 3.2的默认实例化极限深度�?00层，你也可以手工调整实例化深度：
C:\>g++ -ftemplate-depth-3400 -c xytest2.cpp
事实上，g++ 3.2允许的模板实例化极限深度�q�可以再大一些（我的��试�l�果是不��过3450层）�?nbsp;
因此�Q�在使用模板元编�E�技术时�Q�我们��L��要给出原始模板的特化版（局部特化版或完全特化版或兼而有之）�Q�以作�ؓ递归模板实例化的�l�结准则�?nbsp;

利用模板元编�E�技术解开循环

模板元编�E�技术最早的实际应用之一是用于数��D��中的解循环。�D个例子，对一个数�l�进行求和的常见�Ҏ(gu��)��是：
// sumarray.h

template
inline T sum_array(int Dim, T* a)
{
    T result = T();
    for (int i = 0; i < Dim; ++i)
    {
        result += a[i];
    }
    return result;
}
�q�当然可行，但我们也可以利用模板元编�E�技术来解开循环�Q?nbsp;
// sumarray2.h

// 原始模板
template
class Sumarray
{
public:
    static T result(T* a)
    {
        return a[0] + Sumarray::result(a+1);
    }
};

// 作�ؓ�l�结准则的局部特化版
template
class Sumarray<1, T>
{
public:
    static T result(T* a)
    {
        return a[0];
    }
};

用法如下�Q?nbsp;

// sumarraytest2.cpp

#include
#include "sumarray2.h"

int main()
{
    int a[6] = {1, 2, 3, 4, 5, 6};
    std::cout << " Sumarray<6>(a) = " << Sumarray<6, int>::result(a);
}
当我们计��Sumarray<6, int>::result(a)�Ӟ��实例化过�E�如下：
Sumarray<6, int>::result(a)
= a[0] + Sumvector<5, int>::result(a+1)
= a[0] + a[1] + Sumvector<4, int>::result(a+2)
= a[0] + a[1] + a[2] + Sumvector<3, int>::result(a+3)
= a[0] + a[1] + a[2] + a[3] + Sumvector<2, int>::result(a+4)
= a[0] + a[1] + a[2] + a[3] + a[4] + Sumvector<1, int>::result(a+5)
= a[0] + a[1] + a[2] + a[3] + a[4] + a[5]
可见�Q��@环被展开为a[0] + a[1] + a[2] + a[3] + a[4] + a[5]。这�U�直截了当的展开�q�算几乎��L��比��@环来得更有效率�?nbsp;
也许拿一个有着600万个元素的数�l�来例证循环开解的优势可能更有说服力。生成这��L��数组很容易，有兴��，你不妨测试、对比一下�?nbsp;

模板元编�E�在数��D��程序库中的应用

Blitz++之所�?#8220;快如闪电”�Q�这正是blitz的字面含义）�Q�离不开模板元程序的功劳。Blitz++淋漓��致��C��用了元编�E�技术，你可以到�q�些文�g源代码中�H�探�I�竟�Q?nbsp;

dot.h

matassign.h

matmat.h

matvec.h

metaprog.h

product.h

sum.h

vecassign.h

让我们看看Blitz++�E�序库dot.h文�g中的模板元程序：

template
class _bz_meta_vectorDot {
public:
    enum { loopFlag = (I < N-1) ? 1 : 0 };

    template
    static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
    f(const T_expr1& a, const T_expr2& b)
    {
        return a[I] * b[I] + _bz_meta_vectorDot::f(a,b);
    }

    template
    static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
    f_value_ref(T_expr1 a, const T_expr2& b)
    {
        return a[I] * b[I] + _bz_meta_vectorDot::f(a,b);
    }

    template
    static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
    f_ref_value(const T_expr1& a, T_expr2 b)
    {
        return a[I] * b[I] + _bz_meta_vectorDot::f(a,b);
    }

    template
    static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, P_numtype2)
    dotWithArgs(const T_expr1& a, P_numtype2 i1, P_numtype2 i2=0,
                P_numtype2 i3=0, P_numtype2 i4=0, P_numtype2 i5=0, P_numtype2 i6=0,
                P_numtype2 i7=0, P_numtype2 i8=0, P_numtype2 i9=0, P_numtype2 i10=0)
    {
        return a[I] * i1 + _bz_meta_vectorDot::dotWithArgs
                                                                                   (a, i2, i3, i4, i5, i6, i7, i8, i9);
    }
};

template<>
class _bz_meta_vectorDot<0,0> {
public:
    template
    static inline _bz_meta_nullOperand f(const T_expr1&, const T_expr2&)
    { return _bz_meta_nullOperand(); }

    template
    static inline _bz_meta_nullOperand
    dotWithArgs(const T_expr1& a, P_numtype2 i1, P_numtype2 i2=0,
                P_numtype2 i3=0, P_numtype2 i4=0, P_numtype2 i5=0, P_numtype2 i6=0,
                P_numtype2 i7=0, P_numtype2 i8=0, P_numtype2 i9=0, P_numtype2 i10=0)
    {
        return _bz_meta_nullOperand();
    }
};
�q�段代码�q�比它乍看上�ȝ��单。_bz_meta_vectorDot�c�L��板��用了一个��时变量loopFlag来存放每一步��@环条件的评估�l�果�Q��ƈ使用了一个完全特化版作�ؓ递归�l�结的条件。需要说明的是，和几乎所有元�E�序一��P��q�个临时变量作用发挥于编译期�Q��ƈ��从�q�行代码中优化掉�?nbsp;
Todd是在Blitz++数值数�l�库的主要作者。这个程序库�Q�以及MTL和POOMA�{�程序库�Q�例证了模板元程序可以�ؓ我们带来更加高效的数��D��性能。Todd宣称Blitz++的性能可以和对应的Fortran�E�序库媲��?br>
Loki�E�序库：�zȝ��模板元编�E�技术的典范

模板元编�E�的价��g��仅在于高性能数��D��吗�Q�不仅如此。Loki�E�序库以�Ҏ(gu��)��型模式的开创性工作闻名于C++�C��。它很��y妙地利用了模板元�~�程技术实��C��Typelist�l��g。Typelist是实现Abstract Factory、Visitor�{�泛型模式不可或�~�的基础设施�?nbsp;
��像C++标准库组件std::list提供对一�l�数值的操作一��P��Typelist可以用来操纵一�l�类型，其定义非常简单（摘自Loki�E�序库Typelist.h单元�Q�：
template
struct Typelist
{
    typedef T Head;
    typedef U Tail;
};
昄��Q�Typelist没有��M��状态，也未定义��M��操作�Q�其作用只在于携带类型信息，它�ƈ未打��被实例化，因此�Q�对于Typelist的�Q何处理都必然发生于编译期而非�q�行期�?nbsp;
Typelist可以被无限扩展，因�ؓ模板参数可以是�Q何类型（包括该模板的其他��L��体）。例如：
Typelist > >
��是一个包含有char、int、float三种�c�d��的Typelist�?nbsp;
按照Loki的约定，每一个Typelist都必��M��NullType�l�尾。NullType的作用类��g��传统C字符串的“\0”�Q�它被声明于Loki�E�序库的NullType.h文�g中：
class NullType;
NullType只有声明�Q�没有定义，因�ؓLoki�E�序库永�q�都不需要创��Z��个NullType对象�?nbsp;
让我们看看IndexOf模板元程序，它可以在一个Typelist中查扄��定类型的位置�Q�摘自Loki�E�序库的Typelist.h单元�Q�：
template
struct IndexOf;

template
struct IndexOf
{
    enum { value = -1 };
};

template
struct IndexOf, T>
{
    enum { value = 0 };
};

template
struct IndexOf, T>
{
private:
    enum { temp = IndexOf::value };
public:
    enum { value = (temp == -1 ? -1 : 1 + temp) };
};

IndexOf提供了一个原始模板和三个局部特化版。算法非常简单：如果TList�Q�就是一个Typelist�Q�是一个NullType�Q�则value�?1。如果TList的头部就是T�Q�则value�?。否则将IndexOf施行于TList的尾部和T�Q��ƈ��评估结果置于一个��时变量temp中。如果temp�?1�Q�则value�?1�Q�否则value�? + temp�?nbsp;
��Z��加深你对Typelist采用的模板元�~�程技术的认识�Q�我从Loki�E�序库剥��d��如下代码�Q�放入一个typelistlite.h文�g中：
// typelistlite.h

// 声明Nulltype
class NullType;

// Typelist的定�?/font>
template
struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

// IndexOf的定�?nbsp;

// IndexOf原始模板
template struct IndexOf;

// 针对NullType的局部特化版
template
struct IndexOf
{
    enum { value = -1 };
};

// 针对“Tlist头部��是我们要查扄��T”的局部特化版
template
struct IndexOf, T>
{
    enum { value = 0 };
};

// 处理Tlist��N��的局部特化版
template
struct IndexOf, T>
{
private:
    enum { temp = IndexOf::value };
public:
    enum { value = (temp == -1 ? -1 : 1 + temp) };
};

��试�E�序如下�Q?nbsp;

// typelistlite_test.cpp

#include
#include "typelistlite.h"

// 自定义类型Royal
class Royal {};

// 定义一个包含有char、int、Royal和float的Typelist
typedef Typelist > > > CIRF;

int main()
{
    std::cout << "IndexOf::value = " << IndexOf::value << "\n";
    std::cout << "IndexOf::value = " << IndexOf::value << "\n";
    std::cout << "IndexOf::value = " << IndexOf::value << "\n";
}

�E�序输出如下�Q?nbsp;

IndexOf::value = 1
IndexOf::value = 2
IndexOf::value = -1

�l�语

模板元编�E�技术�ƈ非都是优点，比方��_��模板元程序编译耗时�Q�带有模板元�E�序的程序生成的代码��寸要比普通程序的大，而且通常�q�种�E�序调试��h��也比常规�E�序困难得多。另外，对于一些程序员来说�Q�以�c�L��板的方式描述��法也许有点抽象�?nbsp;
�~�译耗时的代��h��来的是卓��的�q�行期性能。通常来说�Q�一个有意义的程序的�q�行�ơ数�Q�或服役旉��Q��L��q�远��过�~�译�ơ数�Q�或�~�译旉��Q�。�ؓ�E�序的用户带来更好的体验�Q�或者�ؓ性能要求严格的数��D��换取更高的性能�Q�值得�E�序员付��L��代�h(hu��n)�?nbsp;
很难惌��模板元编�E�技术会成�ؓ每一个普通程序员的日常工��P��相反�Q�就像Blitz++和Loki那样�Q�模板元�E�序几乎��L��应该被封装在一个程序库的内部。对于库的用��h��_��它应该是透明的。模板元�E�序可以�Q�也应该�Q�用作常规模板代码的内核�Q��ؓ关键的算法实现更好的性能�Q�或者�ؓ特别的目的实现特别的效果�?nbsp;
模板元编�E�技术首�ơ正式亮�怺�Todd Veldhuizen�?em>Using C++ Template Metaprograms论文之中。这��文章首先发表于1995�q?月的C++ Report期刊上，后来Stanley Lippman�~�辑C++ Gems一书时又收录了它。参考文献中�l�出了这��文章的链接�Q�它�q�描�q�C��许多本文没有描述到的内容�?nbsp;
David Vandevoorde和Nicolai M. Josuttis合著�?em>C++ Templates: The Complete Guide一书花了一整章的篇�q�介�l�模板元�~�程技术，它同��h��本文的参考资料�ƈ且也应该作�ؓ你的补充阅读材料�?nbsp;
Andrei Alexandrescu的天才著�?em>Modern C++ Design: Generic Programming and Design Patterns Applied的第3�?em>Typelists对Typelist有着更�ؓ详尽的描�q��?br>
参考文�?/strong>

1. David Vandevoorde, Nicolai M. Josuttis, C++ Templates: The Complete Guide, Addison Wesley, 2002.
2. Andrei Alexandrescu, Modern C++ Design: Generic Programming and Design Patterns Applied, Addison Wesley, 2001.
3. 侯捷於春�?译，《C++设计新思维》，华中�U�技大学出版�C�，2003�?
4. Todd Veldhuizen, Template Metaprograms, http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html .
5. Todd Veldhuizen, C++ templates as partial evaluation (PEPM99), http://osl.iu.edu/~tveldhui/papers/pepm99/.
6. Erwin Unruh, Prime numbers(Primzahlen - Original), http://www.erwin-unruh.de/primorig.html .
7. Erwin Unruh, Prime numbers(Primzahlen), http://www.erwin-unruh.de/Prim.html .
8. Blitz++, http://www.oonumerics.org/blitz .
9. Loki, http://sourceforge.net/projects/loki-lib .
10. POOMA, http://www.pooma.com.
11. MinGW - Minimalist GNU for Windows, http://sourceforge.net/projects/mingw.

zhaoyg 2009-11-15 14:25 发表评论

�ȝ��型��承中的虚函数问题

zhaoyg — Wed, 28 Oct 2009 04:51:00 GMT
问题1�Q?/span>

class Base1
{
public:
    virtual void f()
    {
        cout << "Base1::f" << endl;
    }
    virtual void g()
    {
        cout << "Base1::g" << endl;
    }
};
class Base2 :public virtual Base1
{
public:

    virtual void f()
    {
        cout << "Base2::f" << endl;
    }
    virtual void g()
    {
        cout << "Base2::g" << endl;
    }
};

class Base3:public virtual Base1
{
public:

    virtual void f()
    {
        cout << "Base3::f" << endl;
    }
    virtual void g()
    {
        cout << "Base3::g" << endl;
    }
};

class Derive : public Base2, public Base3 {
public:
virtual void g() { cout << "Derive::g1" << endl; }
};

以上代码是在论坛中遇见的�Q�当时我�q�没有立��d��应上来这是什么缘故，思烦一阵后�Q�才弄明白�?br>原来�Q�在Derive中没有重写f函数�Q�又因�ؓ当派生类没有重写基类的虚函数�Ӟ��z��c�d��象对该虚函数的调用，��会调用其基�c�M��的版本，而Derive又是多��承，于是在Derive�l�承时就不知道Base1中的虚函数表应该记录哪个版本的f函数�Q�是Base2�Q�还是Base3�?br>因�ؓDerive中已重定义g函数�Q�Base1的虚函数表记录的是Derive::g�?/p>
==============================================================================

问题2�Q?br>代码来源2nd

class Lottery
{
public:
  virtual int draw();
};

class GraphicalObject
{
public:
  virtual int draw();
};

class LotterySimulation: public Lottery,
                         public GraphicalObject
{
  // 没有声明draw
};

LotterySimulation *pls = new LotterySimulation;

pls->draw();   // 错误! ---- 二义

因�ؓLotterySimulation中存在两个名为draw的函敎ͼ�于是调用存在二义性。同�Ӟ��即便更改其中一个draw的访问性也不能避免�q�种二义性，因�ؓ改变一个类成员的访问权限不应该改变�E�序的含义�?br>对于如下代码�Q�仍然存在二义�?br>
class SpecialLotterySimulation: public LotterySimulation
{
public:
  virtual int draw();
};

pls = new SpecialLotterySimulation;

pls->draw();     // 错误!  �q�是有二�?br>
因�ؓ�Q�pls的静态类型是LotterySimulation�Q�而名字的查找是向上进行的�Q�所以即便SpecialLotterySimulation中定义了一个draw�Q�对pls来说他是不会查看SpecialLotterySimilation中的名称的�?/span>

zhaoyg 2009-10-28 12:51 发表评论

{偶尔学习C++标准} �?[对象的复�?- 复制构造与赋值操作符]

zhaoyg — Wed, 07 Oct 2009 12:25:00 GMT
     摘要: 对象的复�?- 复制构造与赋值操作符  阅读全文

zhaoyg 2009-10-07 20:25 发表评论

[ �?] VC++�Q�掀起你的盖头来——谈VC++对象模型

zhaoyg — Mon, 14 Sep 2009 12:35:00 GMT
     摘要: 非常不错的一��文章。正文：--------------------------------------------------------�Q�美�Q�简 �?格雷�E�化    译排版美化：恋花�Ӟ��http://blog.csdn.net/lanphaday�Q�原文地址�Q�http://blog.csdn.net/hellothere/archive/2006/02/27/6117...  阅读全文

zhaoyg 2009-09-14 20:35 发表评论

初识"�q�回��g��?

zhaoyg — Sun, 24 May 2009 15:11:00 GMT
�?lt;C++�~�程思想>2th中文�?�W?2.3.3.2�?#8220;�q�回��g��?#8221;中说�Q�对于处�?#8220;return Integer(left.i + left.i);”�q�种的返回时�Q�编译器直接在目的内存中创徏�Q�且因�ؓ不是创徏局部对象，故可直接调用普通构造函敎ͼ�而不需要复制构造函敎ͼ�但，对于
“
Integer temp;
return temp;
”
�q�样的返回值�Ş式，是需要调用复制构造函数来在目标内存中创徏对象的�?br>
我在VC2005中试了如下的��函敎ͼ�

X f()
{
    X one(5);
    //return one; //因�ؓVC中默认情况下debug模式优化被禁�?release模式优化可用�Q�所以在release模式下直接将one的定义目标内存中;debug则是调用复制构造在目标内存中构�?br>    //return X(4); // release & debug 都直接在目标内存中构造对�?/span>
}

int main()
{
   X test = f();
}

对于�Q?br>Integer temp;
return temp;
�q�种形式�Q�在VC2005中，如果没有��用优化�Q�则不要求复制构造函数可讉K��Q�也��是说复制构造函数都不会被调用�?br>但标准中��_��“Even when the creation of the temporary object is avoided (12.8), all the semantic restrictions must be respected as if the temporary object was created. [ Example: even if the copy constructor is not called, all the semantic restrictions, such as accessibility (clause 11), shall be satisfied.]”�Q�所以还是保留复制构造函数的可访问性吧�?br>
P.S. : 后来了解到VC�?或者说标准允许)对命名对象的�q�回采用“命名�q�回��g��?NRVO)”来进行优化，但是对于�q�种优化只有在某些编译器选项开启后才得以实玎ͼ�臛_��VC是这��L��?br>
2009.6.18 更新

zhaoyg 2009-05-24 23:11 发表评论

{偶尔学习C++标准} �?[初识临时对象生命期]

zhaoyg — Sun, 24 May 2009 07:53:00 GMT
     摘要: 临时对象生命�?nbsp; 阅读全文

zhaoyg 2009-05-24 15:53 发表评论

09�q�之学习计划

zhaoyg — Sun, 17 May 2009 04:43:00 GMT
其实我�ƈ不想写这个所谓的“学习计划”�Q�可以说是有些害怕写�q�东西，因�ؓ我常常是“计划赶不上变�?#8221;�Q�例�?8�q�上半年说是要将C++学完�Q�但后来因�ؓ��p��四��的原因而不得不搁浅�Q�毕竟四�U�不能小视呀�Q�，而后来又因�ؓ一些其他因素致使我直到今年4月䆾才学完C++。可以说�Q�所�?#8220;计划”��是�Ҏ(gu��)��的讽刺。希望这�ơ不要再“讽刺”了，已经没时间了�?br>
2009�q�之内要完成如下内容�Q?br>   初步学会    SQL Server 2005
   初步学会    VC++�~�程
   看完《深入详解VC++�?br>   看完《SQL Server �~�程入门�l�典�?br>   看完《Effective C++�?br>   看完《Exceptional C++�?br>   多学些算法及数据�l�构
   ��量多看些《深入理解计��机�pȝ��》中的内�?br>
但愿�q�次能按时完成�Q务�?/span>

zhaoyg 2009-05-17 12:43 发表评论

[转脓(chu��ng)]void及void指针深层探烦

zhaoyg — Thu, 05 Jun 2008 16:21:00 GMT
1.概述
　　许多初学者对C/C++语言中的void及void指针�c�d��不甚理解�Q�因此在使用上出��C��一些错误。本文将对void关键字的深刻含义�q�行解说�Q��ƈ详述void及void指针�c�d��的��用方法与技巧�?
　　2.void的含�?
　　void的字面意思是“无类�?#8221;�Q�void *则�ؓ“无类型指�?#8221;�Q�void *可以指向��M��c�d��的数据�?
　　void几乎只有“注释”和限制程序的作用�Q�因��Z��来没有�h会定义一个void变量�Q�让我们试着来定义：

void a;
　　�q�行语句�~�译时会出错�Q�提�C?#8220;illegal use of type 'void'”。不�q�，即��void a的编译不会出错，它也没有��M��实际意义�?
　　void真正发挥的作用在于：
　　�Q?�Q?对函数返回的限定�Q?
　　�Q?�Q?对函数参数的限定�?
　　我们��在�W�三节对以上二点�q�行具体说明�?
　　众所周知�Q�如果指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋��|��如果p1和p2指向不同的数据类型，则必��M��用强制类型�{换运��符把赋��D��符双��的指针类型�{换�ؓ左边指针的类型�?
　　例如�Q?
float *p1;
int *p2;
p1 = p2;
　　其中p1 = p2语句会编译出错，提示“'=' : cannot convert from 'int *' to 'float *'”�Q�必��L��为：
p1 = (float *)p2;
　而void *则不同，��M��c�d��的指针都可以直接赋值给它，无需�q�行强制�c�d��转换�Q?
void *p1;
int *p2;
p1 = p2;
　　但这�q�不意味着�Q�void *也可以无需强制�c�d��转换地赋�l�其它类型的指针。因�?#8220;无类�?#8221;可以包容“有类�?#8221;�Q��?#8220;有类�?#8221;则不能包�?#8220;无类�?#8221;。道理很��单，我们可以�?#8220;男�h和女人都是�h”�Q�但不能�?#8220;人是男�h”或�?#8220;人是女�h”。下面的语句�~�译出错�Q?
void *p1;
int *p2;
p2 = p1;
　　提示“'=' : cannot convert from 'void *' to 'int *'”�?
3.void的��?
　　下面�l�出void关键字的使用规则�Q?
　　规则一如果函数没有�q�回��|��那么应声明�ؓvoid�c�d��
　　在C语言中，凡不加返回值类型限定的函数�Q�就会被�~�译器作��回整型值处理。但是许多程序员却误以�ؓ其�ؓvoid�c�d��。例如：
add ( int a, int b )
{
return a + b;
}
int main(int argc, char* argv[])
{
printf ( "2 + 3 = %d", add ( 2, 3) );
}
　　�E�序�q�行的结果�ؓ输出�Q?
　　2 + 3 = 5
　　�q�说明不加返回��D��明的函数的确为int函数�?
　　林锐博士《高质量C/C++�~�程》中提到�Q?#8220;C++语言有很严格的类型安全检查，不允�怸��q�情况（指函��C��加类型声明）发生”。可是编译器�q�不一定这么认定，譬如在Visual C++6.0中上�q�add函数的编译无错也无警告且�q�行正确�Q�所以不能寄希望于编译器会做严格的类型检查�?
　　因此�Q��ؓ了避免�؜乱，我们在编写C/C++�E�序�Ӟ��对于��M��函数都必��M��个不漏地指定其类型。如果函数没有返回��|��一定要声明为void�c�d��。这既是�E�序良好可读性的需要，也是�~�程规范性的要求。另外，加上void�c�d��声明后，也可以发挥代码的“自注�?#8221;作用。代码的“自注�?#8221;即代码能自己注释自己�?
规则�?如果函数无参敎ͼ�那么应声明其参数为void
　　在C++语言中声明一个这��L��函数�Q?
int function(void)
{
return 1;
}
　　则进行下面的调用是不合法的：
function(2);
　　因�ؓ在C++中，函数参数为void的意思是�q�个函数不接受�Q何参数�?
　　我们在Turbo C 2.0中编译：
#include "stdio.h"
fun()
{
return 1;
}
main()
{
printf("%d",fun(2));
getchar();
}
　　�~�译正确且输�?�Q�这说明�Q�在C语言中，可以�l�无参数的函��C��送�Q意类型的参数�Q�但是在C++�~�译器中�~�译同样的代码则会出错。在C++中，不能向无参数的函��C��送�Q何参敎ͼ�出错提示“'fun' : function does not take 1 parameters”�?
　　所以，无论在C�q�是C++中，若函��C��接受��M��参数�Q�一定要指明参数为void�?
　　规则�?��心使用void指针�c�d��
　　按照ANSI(American National Standards Institute)标准�Q�不能对void指针�q�行��法操作�Q�即下列操作都是不合法的�Q?
void * pvoid;
pvoid++; //ANSI�Q�错�?
pvoid += 1; //ANSI�Q�错�?
//ANSI标准之所以这栯��定，是因为它坚持�Q�进行算法操作的指针必须是确定知道其指向数据�c�d��大小的�?
//例如�Q?
int *pint;
pint++; //ANSI�Q�正��?
　　pint++的结果是使其增大sizeof(int)�?
　　但是大名鼎鼎的GNU(GNU's Not Unix的羃�?则不�q�么认定�Q�它指定void *的算法操作与char *一致�?
因此下列语句在GNU�~�译器中皆正��：
pvoid++; //GNU�Q�正��?
pvoid += 1; //GNU�Q�正��?
　　pvoid++的执行结果是其增大了1�?
　　在实际的�E�序设计中，��合ANSI标准�Q��ƈ提高�E�序的可�U�L��性，我们可以�q�样�~�写实现同样功能的代码：
void * pvoid;
(char *)pvoid++; //ANSI�Q�正��；GNU�Q�正��?
(char *)pvoid += 1; //ANSI�Q�错误；GNU�Q�正��?
　　GNU和ANSI�q�有一些区别，��M��而言�Q�GNU较ANSI�?#8220;开�?#8221;�Q�提供了�Ҏ(gu��)��多语法的支持。但是我们在真实设计�Ӟ��q�是应该��可能地�q�合ANSI标准�?
　　规则�?如果函数的参数可以是��L��c�d��指针�Q�那么应声明其参��Cؓvoid *
　　典型的如内存操作函数memcpy和memset的函数原型分别�ؓ�Q?
void * memcpy(void *dest, const void *src, size_t len);
void * memset ( void * buffer, int c, size_t num );
　　�q�样�Q��Q何类型的指针都可以传入memcpy和memset中，�q�也真实��C��C��内存操作函数的意义，因�ؓ它操作的对象仅仅是一片内存，而不��片内存是什么类型。如果memcpy和memset的参数类型不是void *�Q�而是char *�Q�那才叫真的奇怪了�Q�这��L��memcpy和memset明显不是一�?#8220;�U��a的，��q��低�񔭑�味�?#8221;函数�Q?
下面的代码执行正��：
//�C�Z��Q�memset接受��L��c�d��指针
int intarray[100];
memset ( intarray, 0, 100*sizeof(int) ); //��intarray�?
//�C�Z��Q�memcpy接受��L��c�d��指针
int intarray1[100], intarray2[100];
memcpy ( intarray1, intarray2, 100*sizeof(int) ); //��intarray2拯��l�intarray1
　　有趣的是�Q�memcpy和memset函数�q�回的也是void *�c�d��Q�标准库函数的编写者是多么地富有学问啊�Q?
　　规则�?void不能代表一个真实的变量
　　下面代码都企图让void代表一个真实的变量�Q�因此都是错误的代码�Q?
void a; //错误
function(void a); //错误
　　void体现了一�U�抽象，�q�个世界上的变量都是“有类�?#8221;的，譬如一个�h不是男�h��是女�h�Q�还有�h妖？�Q��?
　　void的出现只是�ؓ了一�U�抽象的需要，如果你正��地理解了面向对象中“抽象基类”的概念，也很�Ҏ(gu��)��理解void数据�c�d��。正如不能给抽象基类定义一个实例，我们也不能定义一个void�Q�让我们�c�L��的称void�?#8220;抽象数据�c�d��”�Q�变量�?
4.�ȝ��
　　��小的void蕴藏着很丰富的设计哲学�Q�作��Z��名程序设计�h员，寚w��题进行深一个层�ơ的思考必然��我们受益匪浅�?br>

来源�Q�弘��?nbsp;   http://www.bansun.com/bbs/thread-4880-1-5.html

zhaoyg 2008-06-06 00:21 发表评论

zhaoyg — Fri, 30 May 2008 05:25:00 GMT
     摘要:   阅读全文

zhaoyg 2008-05-30 13:25 发表评论

久久久综合精品,欧美色大人视频,欧美在线观看视频一区二区三区

自动�c�d��推导�?decltype

�l�一的初始化语法

deleted 函数�?defaulted 函数

nullptr

C++11 的标准库

新的���法

【�{】B(t��i)OOST的编译选项

【�{】function/bind的救赎（上）

[转] 再次�U�结于友元声明是否向外围引入名字

对右值类的一点小认识

[转] Lvalues and Rvalues

�ȝ��型��承中的虚函数问题

{偶尔学习C++标准} �?[对象的复�?- 复制构造与赋值操作符]

[ �?] VC++�Q�掀起你的盖头来——谈VC++对象模型

初识"�q�回��g���?

{偶尔学习C++标准} �?[初识临时对象生命期]

09�q�之学习计划

[转脓(chu��ng)]void及void指针深层探烦

新的��法

初识"�q�回��g��?