亚洲愉拍自拍另类高清精品,欧美精品性视频,欧美专区一区二区三区

陈梓�?vczh) — Thu, 21 Mar 2013 03:55:00 GMT

今天我写了一个给Visual C++用的配置�Q�用来让VC++在显�C��己写的字�W�串和容器等设施变得跟显�C�STL一��h��亮。VC++的可配置型还是很高的�Q�我们只要写一个xml�Q�就可以改变调试器对自己的数据结构的昄��?

在这里我��单地介绍一下用法。假讑֤�家觉得vlpp�Q�Vczh Library++�Q�也��是GacUI用的那个库）的WString啊List�q�些东西在调试器里面昄��出来的东西太丑，��可以用以下三步来修改它�?/p>

1�Q�去http://gac.codeplex.com/SourceControl/changeset/view/99419#2395529下蝲我写的那个natvis文�g。这个文件在整个zip包里面的位置是Common\vlpp.natvis
2�Q�把�q�个文�g复制到C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\Packages\Debugger\Visualizers�Q�如果��用默认安装�\径的话）
3�Q�重启你最喜爱的Visual Studio 2012�Q�就可以看到下面的东西了�Q?/p>

�I�的��指针

有东西的��指针

有内容的“惰性计��?#8221;�c?/p>

有内容但是还没计��的“惰性计��?#8221;�c?/p>

没内容的“惰性计��?#8221;�c?/p>

新鲜热��G的容�?/p>

新鲜热��G的映��?/p>

��p��一对多的映��也是如此的新鲜热��G

List>的互相嵌套也是如此的完美

如果大家惛_��自己的Customized Visualizer的话�Q�可以去参考微软良心提供的文档http://msdn.microsoft.com/en-us/library/vstudio/jj620914.aspx�Q�然后按照上面的步骤写自��q��natvis文�g。在�q�里我把我的natvis贴上来，以供参考：

xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

  <Type Name="vl::ObjectString<wchar_t>">
    <DisplayString>{{ size={length}, buffer={buffer+start,su} }}DisplayString>
    <StringView>buffer+start,suStringView>
    <Expand>
      <Item Name="[size]">lengthItem>
      <ArrayItems>
        <Size>lengthSize>
        <ValuePointer>buffer+startValuePointer>
      ArrayItems>
    Expand>
  Type>

  <Type Name="vl::ObjectString<char>">
    <DisplayString>{{ size={length}, buffer={buffer+start,s} }}DisplayString>
    <StringView>buffer+start,sStringView>
    <Expand>
      <Item Name="[size]">lengthItem>
      <ArrayItems>
        <Size>lengthSize>
        <ValuePointer>buffer+startValuePointer>
      ArrayItems>
    Expand>
  Type>

  <Type Name="vl::collections::List<*,*>">
    <AlternativeType Name="vl::collections::SortedList<*,*>"/>
    <AlternativeType Name="vl::collections::Array<*,*>"/>
    <DisplayString>{{ size={count} }}DisplayString>
    <Expand>
      <Item Name="[size]">countItem>
      <ArrayItems>
        <Size>countSize>
        <ValuePointer>bufferValuePointer>
      ArrayItems>
    Expand>
  Type>

  <Type Name="vl::collections::Dictionary<*,*,*,*>">
    <AlternativeType Name="vl::collections::Group<*,*,*,*>"/>
    <DisplayString>{{ size={keys.count} }}DisplayString>
    <Expand>
      <Item Name="[size]">keys.countItem>
      <Item Name="Keys">keysItem>
      <Item Name="Values">valuesItem>
    Expand>
  Type>

  <Type Name="vl::Ptr<*>">
    <AlternativeType Name="vl::ComPtr<*>"/>
    <DisplayString Condition="reference == 0">[empty]DisplayString>
    <DisplayString Condition="reference != 0">{*reference}DisplayString>
    <Expand>
      <Item Condition="reference != 0" Name="[ptr]">referenceItem>
    Expand>
  Type>

  <Type Name="vl::Lazy<*>">
    <DisplayString Condition="internalValue.reference == 0">[empty]DisplayString>
    <DisplayString Condition="internalValue.reference != 0 && internalValue.reference->evaluated == false">[not evaluated]DisplayString>
    <DisplayString Condition="internalValue.reference != 0 && internalValue.reference->evaluated == true">{internalValue.reference->value}DisplayString>
    <Expand>
      <Item Condition="internalValue.reference != 0 && internalValue.reference->evaluated == true" Name="[value]">internalValue.reference->valueItem>
    Expand>
  Type>

  <Type Name="vl::ObjectBox<*>">
    <DisplayString>{object}DisplayString>
    <Expand>
      <ExpandedItem>objectExpandedItem>
    Expand>
  Type>

  <Type Name="vl::Nullable<*>">
    <DisplayString Condition="object == 0">[empty]DisplayString>
    <DisplayString Condition="object != 0">{*object}DisplayString>
    <Expand>
      <ExpandedItem Condition="object != 0">*objectExpandedItem>
    Expand>
  Type>

AutoVisualizer>

陈梓�?vczh) 2013-03-21 11:55 发表评论

陈梓�?vczh) — Sat, 14 Jan 2012 06:09:00 GMT

    GacUI�l�于�q�入制作dll的阶�D�了。昨天上传了一个新的工�E�，�?a style="text-decoration: underline" target="_blank">Vczh Library++3.0�Q�E:\Codeplex\vlpp\Workspace\Tools\Release\SideProjects\GacUI\GacUI.sln�Q�。这里面一共有三个工程�Q�有两个是工��P��一个是dll�?br />
    ��Z��~�译出带反射的控件库�Q�因此每一个控仉��可以获得一个ITypeDescriptor对象。但是控件库一共有几十个类上千个函敎ͼ�我不可能一个一个去实现的（��h��惛_��现IDispatcher的时候）。根�?a style="text-decoration: underline" href="http://www.shnenglu.com/vczh/archive/2012/01/11/164003.html" target="_blank">上一��博�?/a>讨论�q�技术，我将使用一个程序来读pdb生成C++代码。详�l�的计划如下�Q?br />
    1�Q�制作一个_GacPDB工程。这是一个exe�Q�但是是没用的，唯一的用处就是他引用了GacUI.dll所需要的所有源代码�Q�然后靠�~�译器��生PDB文�g�?br />    2�Q�制作一个_TranslatePDBtoXML工程。这是一个exe�Q�从PDB抽取�c�d��明�?br />    3�Q�制作一个_TranslateXMltoCode。顾名思义�Q�不�q�现在还没做�Q�原理是一��L��?br />    4�Q�GacUI.dll。这个dll包含了所有的控�g的实玎ͼ��q�有_TranslateXMLtoCode产生的所有代码�?br />
    现在我的目标是，先编译_Translate*工程�Q�然后编译_GacPDB产生pdb后自动调用它们，生成代码�l�束之后开始合�q�编译GacUI.dll。所有的�q�些东西都需要在VisualStudio�?#8220;Rebuild Solution”里面完成。�ؓ了完成这个目标，我创��些工�E�之后，按照下面的方法修改了工程属性：

1 _TranslatePDBtoXML:
2     post build action:
3         copy $(ProjectDir)msdia100.dll $(SolutionDir)$(Configuration)\msdia100.dll
4 _GenPDB:
5     references:
6         _TranslatePDBtoXML
7     post build action:
8         $(SolutionDir)$(Configuration)\_TranslatePDBtoXML.exe $(SolutionDir)Debug\_GenPDB.pdb $(SolutionDir)_GenPDB.xml
9 GacUI:
10     references:
11         _GenPDB

    1�Q�工�E�A引用了工�E�B的话�Q�那么只有当B完全�~�译好之后才会编译A。因此上面的配置��阻止三个工�E��^行编译，强制他们按照_TranslatePDBtoXML、_GenPDB和GacUI的顺序来�?br />    2�Q�_TranslatePDBtoXML�~�译好之后，会把它依赖的msdia100.dll复制到编译出来的exe旁边�Q�以供接下来调用�?br />    3�Q�_GenPDB�~�译好之后，pdb已经产生了。这个时候它会自动调用上一步编译出来的_TranslatePDBtoXML�Q�读取pdb�Q�输出xml
    4�Q�（接下来要做的�Q�调用_TranslateXMLtoCode�Q�输入xml�Q�输出C++代码
    5�Q�这个时候，生成的C++代码已经��q�A了，所以开始编译GacUI�?br />
    附加的好处还有一个。因为_GenPDB引用了GacUI的cpp�Q�所以当GacUI的源代码修改的时候，_GenPDB也会感应刎ͼ�从而在下次�~�译GacUI的时候先开始编译_GenPDB。�ƈ且因为GacUI依赖了_GenPDB�Q�所以_GenPDB仍然会先�~�译。而且�q�种依赖关系是无害的�Q�因为_GenPDB没有输出lib�Q�因此GacUI.dll在运行的时候完全不需要_GenPDB.exe的存在�?br />
    好了。那把一个个的cpp文�g��d��到_GenPDB也是在太�ȝ��了，所以我投机取��y了一下：

1 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\GuiApplication.cpp"
2 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\GuiBasicControls.cpp"
3 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\GuiListControls.cpp"
4 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\GuiTextControls.cpp"
5 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\GuiWindowControls.cpp"
6 //---------------------------------------------------------------
7 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiComboControls.cpp"
8 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiContainerControls.cpp"
9 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiListViewControls.cpp"
10 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiMenuControls.cpp"
11 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiTextListControls.cpp"
12 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\ExtendedControls\GuiTreeViewControls.cpp"
13 //---------------------------------------------------------------
14 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\Styles\GuiCommonStyles.cpp"
15 #include "..\..\..\..\..\Candidate\GUI\GUI\Controls\Styles\GuiWin7Styles.cpp"
16 //---------------------------------------------------------------
17 #include "..\..\..\..\..\Candidate\GUI\GUI\GraphicsElement\GuiGraphicsComposition.cpp"
18 #include "..\..\..\..\..\Candidate\GUI\GUI\GraphicsElement\GuiGraphicsElement.cpp"
19 #include "..\..\..\..\..\Candidate\GUI\GUI\GraphicsElement\GuiGraphicsEventReceiver.cpp"
20 #include "..\..\..\..\..\Candidate\GUI\GUI\GraphicsElement\GuiGraphicsHost.cpp"
21 #include "..\..\..\..\..\Candidate\GUI\GUI\GraphicsElement\GuiGraphicsTextElement.cpp"
22 //---------------------------------------------------------------
23 #include "..\..\..\..\..\Candidate\GUI\GUI\NativeWindow\GuiNativeWindow.cpp"
24 #include "..\..\..\..\..\Candidate\GUI\GUI\NativeWindow\Windows\WinNativeWindow.cpp"
25 //---------------------------------------------------------------
26 #include "..\..\..\..\..\Candidate\GUI\GUI\Reflection\GuiTypeDescriptor.cpp"
27 //---------------------------------------------------------------
28 #include "..\..\..\..\..\Library\Basic.cpp"
29 #include "..\..\..\..\..\Library\Exception.cpp"
30 #include "..\..\..\..\..\Library\String.cpp"
31 #include "..\..\..\..\..\Library\Threading.cpp"
32 #include "..\..\..\..\..\Library\Collections\Operation.cpp"
33 //---------------------------------------------------------------
34 #include <Windows.h>
35
36 int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int CmdShow)
37 {
38 return 0;
39 }

啊哈哈哈哈（拖走

VisualStudio的功能是强大的。只要善于��用，或者配合MSBuild�Q�所起到的威力将毫不亚于某些著名工具链。而且VisualStudio�~�译器��生的文�g�Q�基本上VisualStudio都有提供API供你阅读�Q�所以也可以做很多事情，譬如我这��文章说的这��P��充当了一个编译器的扩展，而且完美集成�?img src ="http://www.shnenglu.com/vczh/aggbug/164167.html" width = "1" height = "1" />

陈梓�?vczh) 2012-01-14 14:09 发表评论

C++实用技巧（四）

陈梓�?vczh) — Sun, 27 Jun 2010 12:19:00 GMT

复杂的东西写多了�Q�如今写点简单的好了。由于功能上的需要，Vczh Library++3.0被我搞得很离谱。�ؓ了开发维护的遍历、减��粗心犯下的错误以及增强单元��试、回归测试和��试工具�Q�因此记录下一些开发上的小技巧，以便抛砖引玉�Q�造福他�h。欢�q�高手来��P��菜鸟膜拜�?br>
之前的文�?/a>讲了指针和内存的一些问题，今天说一下单元测试的问题。如果在团队里面没有对单元测试的框架有要求的话，其实我们可以使用一个最��单的�Ҏ(gu��)��来搭建在IDE里面�q�行的单元测试框�Ӟ��整个框架只需十几行代码。我们先来考虑一下功能最��的单元��试框架需要完成什么样的内宏V��首先我们要�q�行一个一个的��试用例�Q�其�ơ在一个测试用例里面我们要��查一些条件是否成立。�D个例子，我们写一个函数将两个字符串连接�v来，一般来说要�q�行下面的测试：

1 #include "MyUnitTestFramework.h"//�{�一下我们会展示一下如何用最��的代码完成�q�个头文件的内容
2 #include ""
3
4 TEST_CASE(StringConcat)
5 {
6   TEST_ASSERT(concat("a", "b")=="ab");
7   TEST_ASSERT(concat("a", "")=="a");
8   TEST_ASSERT(concat("", "b")=="b");
9   TEST_ASSERT(concat("", "")=="");
10   .
11 }
12
13 int wmain()
14 {
15   return 0;
16 }

如果我们的单元测试框架可以这么写�Q�那昄��做�v什么事情来都会方便很多�Q�而且不需要向一些其他的��试框架一��h��册一大堆东西�Q�或者是写一大堆配置函数。当然这�ơ我们只做功能最��的��试框架�Q�这个框枉��了运行测试以外，不会有其他功能，譬如选择哪些��试可以�q�行啦，�q�是在出错的时候log一些什么啦之类。之所以要在IDE里面�q�行�Q�是因�ؓ我们如果做到TEST_ASSERT中出现false的话�Q�立��d��该行崩溃�Q�那么IDE��׃��帮你定位到出错的TEST_ASSERT中去�Q�然后给你显�C�所有的上下文信息，譬如说callstack啦什么的。友好的工具不用��直对不�v自己啊，�q�吗非得把单元测试做得那么复杂捏�Q�凡是单元测试，��L��要全部运行通过才能提交代码的�?br>
那么我们来看看上面的单元��试的代码。首先写了TEST_CASE的那个地方，大括号里面的代码会自动运行。其�ơTEST_ASSERT会在表达式是false的时候崩溃。先从简单的入手吧。如何制造崩溃呢�Q�最��单的办法��是抛异常：

1 #define TEST_ASSERT(e) do(if(!(e))throw "今晚没饭吃�?;}while(0)

�q�里面有两个要注意的地方。首先e要加上小括号�Q�不然取反操作符��有可能做出错误的行为。譬如说当e是a+b==c的时候，加了��括号就变成if(!(a+b==c))...�Q�没有加��括号就变成if(!a+b==c)...�Q�意思就完全变了。第二个��L��的地�Ҏ(gu��)��我��用do{...}while(0)把语句包围�v来了。这样做的好处是可以在�Q何时候TEST_ASSERT(e)都像一个语句。譬如我们可能这么写�Q?br>

1 if(a)
2   TEST_ASSERT(x1);
3 else if(b)
4 {
5   TEST_ASSERT(x2);
6   TEST_ASSERT(x3);
7 }

如果没有do{...}while(0)包围��h��Q�这个else��׃��被绑定到宏里面的那个if�Q�你的代码就被偷��h��掉了�?br>
那么现在剩下TEST_CASE(x){y}了。什么东西可以在main函数外面自动�q�行呢？�q�个我想熟�?zh��n)�C++的�h都会知道�Q�就是全局变量的构造函数啦。所以TEST_CASE(x){y}那个大括号里面的y只能在全局变量的构造函数里面调用。但是我们知道写一个类的时候，构造函数的大括号写完了�Q�后面还有类的大括号�Q�全局变量的名�U�ͼ�和最�l�的一个分受��ؓ了把�q�些��L��Q�那么显然{y}应该属于一个普通的函数。那么全局变量如何能够使用�q�个函数呢？�Ҏ(gu��)��很简单，把函数前�|�声明一下就行了�Q?br>

那我们来看看TEST_CASE(x){y}�I�竟会被��译成什么代码：

1 extern void TESTCASE_x();
2 namespace vl_unittest_executors
3 {
4     class TESTCASE_RUNNER_x
5     {
6     public:
7         TESTCASE_RUNNER_x()
8         {
9             TESTCASE_x();
10         }
11     } TESTCASE_RUNNER_x_INSTANCE;
12 }
13 void TESTCASE_x(){y}

    ��C��q�里是不是很清楚了捏�Q�首先在main函数�q�行之前TESTCASE_RUNNER_x_INSTANCE变量会初始化�Q�然后调用TESTCASE_RUNNER_x的构造函敎ͼ�最后运行函数TESTCASE_x�Q�该函数的内�Ҏ(gu��)��然就是{y}了。这里还能学到宏是如何连接两个名字成��Z��个名字，和如何写多行的宏的�?br>
    于是MyUnittestFramework.h��包含这两个宏，其他啥都没有�Q�是不是很方便呢�Q�打开Visual C++�Q�徏立一个工�E�，引用�q�个头文�Ӟ��然后写你的单元测试，最后F5��p��行了�Q�多方便啊，啊哈哈哈�?br>
    �q�里需要注意一点，那些单元��试的顺序是不受��C��证的�Q�特别是你��用了多个cpp文�g的情况下。于是你在��用这个测试框架的同时�Q�会被迫保证执行一�ơ单元测试不会对你的全局状态带来什么副作用�Q�以便两个测试用例交换顺序执行的时候仍然能�E�_��C�生相同的�l�果。这对你写单元测试有帮助�Q�而且��Z��让你的代码能够被�q�么��试�Q�你的代码也会写的有条理�Q�不会依赖全局状态，真是一举两得也。而且说不定单元测试用例比你的全局变量的初始化�q�先执行呢，因此��Z��使用�q�个��试框架�Q�你��会不得不把你的全局变量隐藏在一个cpp里面�Q�而暴露出随时可以被调用的一�l�函数出来。这样也可以让你的代码在使用全局状态的时候更加安全�?br>
    今天��p��到这里了。下一��要写什么我�q�没惛_��Q�到时候再说吧�?

陈梓�?vczh) 2010-06-27 20:19 发表评论

C++实用技巧（三）

陈梓�?vczh) — Thu, 24 Jun 2010 07:03:00 GMT

    复杂的东西写多了�Q�如今写点简单的好了。由于功能上的需要，Vczh Library++3.0被我搞得很离谱。�ؓ了开发维护的遍历、减��粗心犯下的错误以及增强单元��试、回归测试和��试工具�Q�因此记录下一些开发上的小技巧，以便抛砖引玉�Q�造福他�h。欢�q�高手来��P��菜鸟膜拜�?br>
    今天是关于内存的最后一��了�?a style="TEXT-DECORATION: underline" href="http://www.shnenglu.com/vczh/archive/2010/06/24/118603.html" target=_blank>上一��文�?/a>讲了��Z��么不能对一个东襉K��便memset。里面的demo代码��Z��点小bug�Q�不�q�我不喜�Ƣ在发文章的时候里面的demo代码也拿�ȝ��译和�q�行�Q�所以大家有什么发现的问题��p��论吧。这样也便于后来的�h不会受到误导。这�ơ说的仍然是构造函数和析构函数的事情，不过我们��通过亲手开发一个智能指针的�Ҏ(gu��)��Q�知道引用计数如何帮助管理资源，以及错误使用引用计数的情��c�?br>
    首先先来看一下智能指针是如何帮助我们��理内存的。现在智能指针的实现非常多，我就假设�q�个�c�d��叫Ptr吧。这跟Vczh Library++ 3.0所使用的实��C��栗��?/p>

1 class Base
2 {
3 public:
4 virtual ~Base(){}
5 };
6
7 class Derived1 : public Base
8 {
9 };
10
11 class Derived2 : public Base
12 {
13 };
14
15 //---------------------------------------
16
17 List<Ptr<Base>> objects;
18 objects.Add(new Derived1);
19 objects.Add(new Derived2);
20
21 List<Ptr<Base>> objects2;
22 objects2.Add(objects[0]);

当然�q�里的List也是Vczh Library++3.0实现的，不过�q�玩意儿跟vector也好跟C#的List也好都是一个概念，因此也就不需要多加解释了。我们可以看到智能指针的一个好处，只要没有循环引用出现�Q�你无论怎么复制它，最�l��L��可以被析构掉的。另一个例子告诉我们智能指针如何处理类型�{换：

1 Ptr<Derived1> d1=new Derived1;
2 Ptr<Base> b=d1;
3 Ptr<Derived2> d2=b.Cast<Derived2>();
4 // d2是空�Q�因为b指向的是Derived1而不是Derived2�?/span>

    �q�就如同我们Derived1*可以隐式转换到Base*�Q�而当你��用dynamic_cast(static_cast(new Derived1))会得�?一栗��智能指针在帮助我们析构对象的同�Ӟ��也要做好�c�d��转换的工作�?br>
    好了�Q�现在先让我们一步一步做出那个Ptr。我们需要清楚这个智能指针所要实现的功能是什么，然后我们一个一个来做。首先让我们列出一张表�Q?br>    1、没有参数构造的时候，初始化�ؓ�I?br>    2、��用指针构造的时候，拥有那个指针�Q��ƈ且在没有��M��指针指向那个指针的时候删除掉该指针�?br>    3、智能指针进行复制的时候，两个��指针共同拥有该内部指针�?br>    4、智能指针可以��用新的智能指针或裸指针重新赋倹{�?br>    5、需要支持隐式指针类型�{换，static_cast不支持而dynamic_cast支持的�{换则使用Cast()成员函数来解冟�?br>    6、如果一个裸指针直接用来创徏两个��指针的话�Q�期望的情况是当两个��指针析构掉的时候，该指针会被delete两次从而崩溃�?br>    7、不处理循环引用�?br>
    最后两点实际上是错误��用智能指针的最常见的两�U�情��c��我们从1�?一个一个实现。首先是1。智能指针可以隐式�{换成bool�Q�可以通过operator->()拿到内部的T*。在没有使用参数构造的时候，需要�{换成false�Q�以及拿�?�Q?br>

1 template<typename T>
2 class Ptr
3 {
4 private:
5   T* pointer;
6   int* counter;
7
8   void Increase()
9   {
10     if(counter)++*counter;
11   }
12
13   void Decrease()
14   {
15     if(counter && --*counter==0)
16     {
17       delete counter;
18       delete pointer;
19       counter=0;
20       pointer=0;
21     }
22   }
23
24 public:
25   Ptr():pointer(0),counter(0)
26   {
27   }
28
29   ~Ptr()
30   {
31     Decrease();
32   }
33
34   operator bool()const
35   {
36     return counter!=0;
37   }
38
39   T* operator->()const
40   {
41     return pointer;
42   }
43 };

在这里我们实��C��构造函数和析构函数。构造函数把内部指针和引用计数的指针都初始化为空�Q�而析构函数则�q�行引用计数的减一操作。另外两个操作符重蝲很容易理解。我们主要来看看Increase函数和Decrease函数都分别做了什么。Increase函数在引用计数存在的情况下，把引用计数加一。而Decrease函数在引用计数存在的情况下，把引用计数减一�Q�如果引用计数在减一�q�程中变成了0�Q�则删掉拥有的资源�?br>
当然��C��q�个时候智能指针还不能用，我们必须替他加上复制构造函敎ͼ�operator=操作�W�重载以及��用指针赋值的情况。首先让我们来看使用指针赋值的话我们应该加上什么：

1   Ptr(T* p):pointer(0),counter(0)
2   {
3     *this=p;
4   }
5
6   Ptr<T>& operator=(T* p)
7   {
8     Decrease();
9     if(p)
10     {
11       pointer=p;
12       counter=new int(1);
13     }
14     else
15     {
16       pointer=0;
17       counter=0;
18     }
19     return *this;
20   }

�q�里�q�是偷工减料了的�Q�构造函数接受了指针的话�Q�还是�{�l�operator=去调用了。当一个智能指针被一个新指针赋值的时候，我们首先要减掉一个引用计敎ͼ�因�ؓ原来的指针再也不被这个智能指针共享了。之后就�q�行判断�Q�如果来的是0�Q�那么就变成�I�。如果不�?�Q�就拥有该指针，引用计数初始化成1。于是我们就可以�q�么使用了：

1 Ptr<Base> b=new Derived1;
2 Ptr<Derived2> d2=new Derived2;

让我们开始复制他们吧。复制的要领是，先把之前拥有的指针脱��L��Q�然后连接到一个新的智能指针上面去。我们知道非�I�智能指针有多少个，�ȝ��引用计数的和��是多少�Q�只是分配到各个指针上面的数字不一栯��已�Q?br>

1   Ptr(const Ptr<T>& p):pointer(p.pointer),counter(p.counter)
2   {
3     Increase();
4   }
5
6   Ptr<T>& operator=(const Ptr<T>& p)
7   {
8     if(this!=&p)
9     {
10       Decrease();
11       pointer=p.pointer;
12       counter=p.counter;
13       Increase();
14     }
15     return *this;
16   }

在上一��文章有朋友指出重蝲operator=的时候需要考虑是不是自��p��值给自己�Q�其实这是很正确的。我们写每一�cȝ��时候，特别是当�c�L��有自己控制的资源的时候，需要非常注意这件事情。当然如果只是复制几个对象而不会new啊delete�q�是close什么handle�Q�那��查不��查也无所谓了。在�q�里我们非常清楚�Q�当增加一个新的非�I�智能指针的时候，引用计数的��d��会加一。当修改一个非�I�智能指针的�l�果也是非空的时候，引用计数的和保持不变。当然这是应该的�Q�因为我们需要在所有非�I�智能指针都被毁掉的时候，释放受保护的所有资源�?br>
��C��q�里一个智能指针基本上已经能用了，但是�q�不能处理父�c�d��cȝ��情况。这个是比较�ȝ��的，一个Ptr事实上没有权限访问Ptr的内部对象。因此我们需要通过友元�c�L��解决�q�个问题。现在让我们来添加两个新的函数吧�Q�从一个�Q意的Ptr复制到Ptr�Q�然后保证只有当C*可以隐式转换成T*的时候编译能够通过�Q?br>

1   template<X> friend class Ptr;
2
3   template<typename C>
4   Ptr(const Ptr<C>& p):pointer(p.pointer),counter(p.counter)
5   {
6     Increase();
7   }
8
9   template<typename C>
10   Ptr<T>& operator=(const Ptr<C>& p)
11   {
12     Decrease();
13     pointer=p.pointer;
14     counter=p.counter;
15     Increase();
16     return *this;
17   }

注意�q�里我们的operator=�q�不用检查是不是自己�l�自��p��|��因�ؓ�q�是两个不同的类�Q�相同的话会调用上面那个operator=的。如果C*不能隐式转换到T*的话�Q�这里的pointer=p.pointer��׃��p�|�Q�从而满��了我们的要求�?br>
现在我们能够做的事情��更多了�Q?br>

1 Ptr<Derived1> d1=new Derived1;
2 Ptr<Base> b=d1;

于是我们只剩下最后一个Cast函数了。这个函数内部��用dynamic_cast来做判断�Q�如果�{换失败，会返回空指针�Q?br>

1   tempalte<typename C>
2   Ptr<C> Cast()const
3   {
4     C* converted=dynamic_cast<C*>(pointer);
5     Ptr<C> result;
6     if(converted)
7     {
8       result.pointer=converted;
9       result.counter=counter;
10       Increase();
11     }
12     return result;
13   }

    �q�是一�U�hack的方法，�q�x��是不鼓励�?#8230;…不过因�ؓ操作的都是Ptr�Q�而且特化Ptr也是使用错误的一�U�，所以这里就不管了。我们会��查dynamic_cast的结果，如果成功了，那么会返回一个非�I�的新智能指针，而且�q�个时候我们也要记住Increase一下�?br>
    好了�Q�基本功能就完成了。当然一个智能指针还要很多其他功能，譬如说比较什么的�Q�这个就你们自己搞定哈�?br>
    指针和内存就说到�q�里了，下一��讲如何利用一个好的IDE构造轻量��单元��试�pȝ��。我们都说好的工兯��够提高生产力�Q�因此这�U�方法不能脱��M��个好的IDE使用�?

陈梓�?vczh) 2010-06-24 15:03 发表评论

C++实用技巧（二）

陈梓�?vczh) — Wed, 23 Jun 2010 18:12:00 GMT

    复杂的东西写多了�Q�如今写点简单的好了。由于功能上的需要，Vczh Library++3.0被我搞得很离谱。�ؓ了开发维护的遍历、减��粗心犯下的错误以及增强单元��试、回归测试和��试工具�Q�因此记录下一些开发上的小技巧，以便抛砖引玉�Q�造福他�h。欢�q�高手来��P��菜鸟膜拜�?br>
    上一��文�?/a>讲到了如何检查内存泄霌Ӏ�其实只要肯用C++的STL里面的高�U�功能的话，内存泄露是很�Ҏ(gu��)��避免的。我在开发Vczh Library++ 3.0的时候，所有的��试用例都保证跑完了没有内存泄露。但是很可惜有些C++团队不能使用异常�Q�更甚者不允许写构造函数析构函��C��c�，前一个还好，后一个简直就是在用C。当然有�q�些变态规定的地方STL都是用不了的�Q�所以我们更加需要扎实的基础来开发C++�E�序�?br>
    今天�q�一��主要还是讲指针的问题。因��Z��一��文章一�W�带�q�，今天��来详细讲内存泄漏或者野指针发生的各�U�情��c��当然我不可能一下子丑և�全部的例子，只能说一些常见的�?br>
    一、错误覆盖内存�?br>
    之前提到的不能随便�ؕmemset其实��是��Z��避免�q�个问题的。其实memcpy也不能�ؕ用，我们来看一个例子，最��单的�Q?br>

1 #define MAX_STRING 20;
2
3 struct Student
4 {
5   char name[MAX_STRING];
6   char id[MAX_STRING];
7   int chinese;
8   int math;
9   int english;
10 };

大家对这�U�结构肯定十分熟�(zh��n)�，毕竟是大学时候经常要写的作业�?#8230;…好了�Q�大家很�Ҏ(gu��)��看得出来�q�其实是C语言的经典写法。我们拿到手之后�Q�一般会先初始化一下，然后赋倹{�?br>

1 Student vczh;
2 memset(&vczh, 0, sizeof(vczh));
3 strcpy(vczh.name, "vczh");
4 strcpy(vczh.id, "VCZH'S ID");
5 vczh.chinese=70;
6 vczh.math=90;
7 vczh.english=80;

��Z��么要在这里��用memset呢？memset的用处是��一�D�内存的每一个字节都讄��成同一个数字。这里是0�Q�因此两个字�W�串成员的所有字节都会变�?。因此在memset了Student之后�Q�我们通过正常�Ҏ(gu��)��来访问name和id的时候都会得到空丌Ӏ�而且如果Student里面有指针的话，0指针代表的是没有指向��M��有效对象�Q�因此这个时候对指针指向的对象进行读写就会立��d��溃。对于其他数��|��0一般作为初始��g��不会有什么问题（double什么的要小心）。这��是我们写程序的时候��用memset的原因�?br>
好了�Q�如今社会进步，人民当家做主了，�ȝ��们再也不需要受到可恶的C语言剥削了，我们可以使用C++�Q�因此我们借助STL的力量把Student改写成下面这�U�带有C++味道的�Ş式：

1 struct Student
2 {
3   std::string name;
4   std::string id;
5   int chinese;
6   int math;
7   int english;
8 };

我们仍然需要对Student�q�行初始化，不然三个分数�q�是随机倹{��但是我们又不想每一�ơ创建的时候都对他们分别进行赋值初始化�?。这个时候你心里可能�q�是想着memset�Q?span style="COLOR: red">�q�就错了�Q�在memset的时候，你会把std::string内部的不知道什么东西也�l�memset掉。假如一个空的std::string里面存放的指针指向的是一个空的字�W�串而不是用0来代表空的时候，一下子内部的指针就被你��h��0�Q�等下std::string的析构函数就没办法delete掉指针了�Q�于�?span style="COLOR: red">内存泄露��出��C��。有些朋友可能不知道上面那句话说的是什么意思，我们现在来模拟一下不能memset的std::string要怎么实现�?br>
��Z��让memset一定出现内存泄�Ԍ��那么std::string里面的指针必��L��q�都指向一个有效的东西。当然我们还需要在字符串进行复制的时候复制指针。我们这里不考虑各种优化技术，用最��单的�Ҏ(gu��)��做一个字�W�串出来�Q?br>

1 class String
2 {
3 private:
4   char* buffer;
5
6 public:
7   String()
8   {
9     buffer=new char[1];
10     buffer[0]=0;
11   }
12
13   String(const char* s)
14   {
15     buffer=new char[strlen(s)+1];
16     strcpy(buffer, s);
17   }
18
19   String(const String& s)
20   {
21     buffer=new char[strlen(s.buffer)+1];
22     strcpy(buffer, s.buffer);
23   }
24
25   ~String()
26   {
27     delete[] buffer;
28   }
29
30   String& operator=(const String& s)
31   {
32     delete[] buffer;
33     buffer=new char[strlen(s.buffer)+1];
34     strcpy(buffer, s.buffer);
35   }
36 };

于是我们来做一下memset。首先定义一个字�W�串变量�Q�其�ơmemset掉，让我们看看会发生什么事情：

1 string s;
2 memset(&s, 0, sizeof(s));

    �W�一行我们构造了一个字�W�串s。这个时候字�W�串的构造函数就会开始运行，因此strcmp(s.buffer, "")==0。第二行我们把那个字�W�串�l�memset掉了。这个时候s.buffer==0。于是函数结束了�Q�字�W�串的析构函数尝试delete�q�个指针。我们知道delete一�?是不会有问题的，因此�E�序不会发生错误�?span style="COLOR: red">我们�zȝ��生把构造函数赋值给buffer的new char[1]�l�丢�?/strong>�Q�铁定发生内存泄�Ԍ��

    好了�Q�提出问题总要解决问题�Q�我们不使用memset的话�Q�怎么初始化Student呢？�q�个十分好做�Q�我们只需要�ؓStudent加上构造函数即可：

1 struct Student
2 {
3   .//不重复那些声�?/span>
4
5   Student():chinese(0),math(0),english(0)
6   {
7   }
8 };

    �q�样��容易多了。每当我们定义一个Student变量的时候，所有的成员都初始化好了。name和id因�ؓstring的构造函��C��自己初始化了�Q�因此所有的成员也都初始化了。加入Student用了一半我们想再初始化一下怎么办呢�Q�也很容易：

1 Student vczh;
2 .//各种使用
3 vczh=Student();

    �l�过一个等��h��作符的调用，旧Student的所有成员就被一个新的初始化�q�的Student�l�覆盖了�Q�就如同我们对一个int变量重新赋��g��样常见。当然因为各�U�复制经�怼�出现�Q�因此我们也要跟上面贴出来的string的例子一��P��实现好那4个函数。至此我十分不理解�ؓ什么某些团队不允许使用构造函敎ͼ�我猜��是��Z��可以memset�Q�其实是很没道理的�?br>
    二、异常�?/strong>

    咋一看内存泄露跟异常好像没什么关�p�，但实际上�q�种情况更容易发生。我们来看一个例子：

1 char* strA=new char[MAX_PATH];
2 if(GetXXX(strA, MAX_PATH)==ERROR) goto RELEASE_STRA;
3 char* strB=new char[MAX_PATH];
4 if(GetXXX(strB, MAX_PATH)==ERROR) goto RELEASE_STRB;
5
6 DoSomething(strA, strB);
7
8 RELEASE_STRB:
9 delete[] strB;
10 RELEASE_STRA:
11 delete[] strA;

    �怿��q�肯定是大家的常用模式。我在这里也不是教唆大家使用goto�Q�不�q�对于这�U�例子来��_��用goto是最优美的解军_��法了。但是大家可以看出来�Q�我们用的是C++�Q�因��里有new。如果DoSomething发生了异常怎么办呢�Q�如果GetXXX发生了异常怎么办呢�Q�我们这里没有�Q何的try-catch�Q�一有异常，函数里克�l�束�Q�两行可怜的delete��׃��会被执行��C��Q?span style="COLOR: red">于是内存泄漏发生�?/strong>�Q?br>
    那我们如何避免这�U�情况下的内存泄露呢�Q�一些可��q��盆友可能会惛_��Q�既然是因�ؓ没有catch异常才发生的内存泄露�Q�那我们来catch吧：

1 char* strA=new char[MAX_PATH];
2 try
3 {
4   if(GetXXX(strA, MAX_PATH)==ERROR) goto RELEASE_STRA;
5   char* strB=new char[MAX_PATH];
6   try
7   {
8     if(GetXXX(strB, MAX_PATH)==ERROR) goto RELEASE_STRB;
9     DoSomething(strA, strB);
10   }
11   catch()
12   {
13     delete[] strB;
14     throw;
15   }
16 }
17 catch()
18 {
19   delete[] strA;
20   throw;
21 }
22
23 RELEASE_STRB:
24 delete[] strB;
25 RELEASE_STRA:
26 delete[] strA;

    你能接受吗？当然是不能的。问题出在哪里呢�Q�因为C++没有try-finally。你看这些代码到处都是雷同的东西�Q�显然我们需要编译器帮我们把�q�些问题搞定。最好的解决�Ҏ(gu��)��是什么呢�Q�显然还是构造函数和析构函数。��M��C��Q?span style="COLOR: red">如果惌��事情成对发生�Q�那么��用构造函数和析构函数�?br>
    �W�一步，GetXXX昄��只能支持C模式的东西，因此我们要写一个支持C++的：

1 bool GetXXX2(string& s)
2 {
3   char* str=new char[MAX_PATH];
4   bool result;
5   try
6   {
7     result=GetXXX(str, MAX_PATH);
8     if(result)s=str;
9   }
10   catch()
11   {
12     delete[] str;
13     throw;
14   }
15   delete[] str;
16   return result;
17 }

    借助�q�个函数我们可以看到�Q�因为有了GetXXX�q�种C的东西，��D��我们多了多少�ȝ��。不�q�这��L��一��x��逸的�Q�有了GetXXX2和修改之后的DoSomething2之后�Q�我们就可以用更��单的�Ҏ(gu��)��来做了：

1 string a,b;
2 if(GetXXX2(a) && GetXXX2(b))
3 {
4   DoSomething2(a, b);
5 }

    多么��单易懂。这个代码在��M��地方发生了异常，所有new的东襉K��会被delete。这��是析构函数的一个好处。一个变量的析构函数在这个变量超��Z��作用域的时候一定会被调用，无论代码是怎么走出�ȝ��?br>
    今天��p��到这里了。说了这么多�q�是惌��大家不要��看构造函数和析构函数。那�U�微不��道的因�ؓ一��部分不是瓶颈的性能问题而放弃构造函数和析构函数的做法，�l�究是要��Z��修bug而加班的。只要明白�ƈ用好了构造函数、析构函数和异常�Q�那么C++的特性也可以跟C一��h��楚明白便于理解，而且写出来的代码更好看的。大家期待第三篇哈�?

陈梓�?vczh) 2010-06-24 02:12 发表评论

陈梓�?vczh) — Tue, 22 Jun 2010 13:16:00 GMT
    复杂的东西写多了�Q�如今写点简单的好了。由于功能上的需要，Vczh Library++3.0被我搞得很离谱。�ؓ了开发维护的遍历、减��粗心犯下的错误以及增强单元��试、回归测试和��试工具�Q�因此记录下一些开发上的小技巧，以便抛砖引玉�Q�造福他�h。欢�q�高手来��P��菜鸟膜拜�?br>
    C++实谓各种语言中的软肋�Q�功能强大，陷阱更强大。当然我认�ؓ一门语�a�用得不好完全是程序员的责任，不过因�ؓC++涉及到的概念实在是太多，想用好实在也不是一件容易的事情。C++开发的时候��L��会遇到各�U�各��L��问题�Q�其中最严重的无非是内存相关的。C语言�׃��l�构��单，内存处理��h��虽然不得力，但�ȝ��来说惯用法已�l�深入�h心，因此也不会造成什么很隑֏�现的错误。C++��׃��一样了。有了虚函数、构造函数、析构函数、复制构造函数和operator=重蝲之后�Q�还是有很多人喜�Ƣ把一个类直接写进文�g��，或者拿来memset�Q�代码一团�ؕ麻，不知�(zh��n)�改也。但是不能因此因噎废食，��像某�h因�ؓC++带来的心智问题太多，自己搞不定，自己团队也搞不定�Q�就说C++不好一栗��?br>
    因此�W�一��文章主要针对内存来讌Ӏ�我们处理内存，�W�一件事��是不要有内存泄霌Ӏ�内存泄露不能等到测试的时候，通过长时间运行程序�ƈ观察��d��理器的�Ҏ(gu��)��来做�Q�这昄��已经晚了。幸好Visual C++�l�了我们一个十分好用的工具�Q�_CrtDumpMemoryLeaks函数。这个函��C��在Debug模式下往Visual Studio的output�H�口打印出那个时候你new�Q�malloc�Q�了但是�q�没delete�Q�free�Q�的所有内存块的地址、长度、前N个字节的内容和其他信息。怎么做呢�Q�其实很��单：

1 #define _CRTDBG_MAP_ALLOC
2 #include <stdlib.h>
3 #include <crtdbg.h>
4 #include <windows.h>
5
6 int wmain(vint argc , wchar_t* args[])
7 {
8     // �q�里�q�行�E�序�Q��ƈ在下面的函数调用之前delete掉所有new的东�?/span>
9     _CrtDumpMemoryLeaks();
10     return 0;
11 }

    我们只需要在注释的地方完成我们程序的功能�Q�然后确信自己已�l�delete掉所有应该delete的东西，最后_CrtDumpMemoryLeaks()函数调用的时候就可以打印出没被delete的东西了。这个方法十分神奇，因�ؓ你只需要在main函数所在的cpp文�g�q�么#include一下，所有的cpp文�g里面的new都会受到监视�Q�跟�q�_��所用的用宏把new�l�换掉的�q�种破方法截然不同。如果你使用了全局变量的话也要��心�Q�因为全局变量的析构函数是在main函数�l�束之后才执行的�Q�因此如果在全局变量的析构函数里面delete的东西仍然会被_CrtDumpMemoryLeaks函数当成泄露掉的资源对待。当然本��为全局变量可以用，但是全局变量的赋值必��d��main里面做，释放也是�Q�除非那个全局变量的构造函数没有申请�Q何内存，所以这也是一个很好的��查方法�?br>
    不过上面也仅仅是一个告诉你有没有内存泄漏的�Ҏ(gu��)��|�了。那么如何避免内存泄露呢�Q�当然在设计一些性能要求没有比操作系�l�更加严格的�E�序的时候，可以使用以下�Ҏ(gu��)��Q?br>    1、如果构造函数new了一个对�?span style="COLOR: red">�q��用成员指针变�?/strong>保存的话�Q�那么必��d��析构函数delete它，�q�且不能有�ؓ了某些便利而将�q�个对象的所有权转让出去的事情发生�?br>    2、在能��用shared_ptr的时候，��量使用shared_ptr。shared_ptr只要你不发生循环引用�Q�那么这个东西可以安全地互相传递、随便你攑֜�什么容器里面添加删除、你��x��哪里��放在哪里，再也不用考虑�q�个对象的生命周期问题了�?br>    3、不要在有构造函数和析构函数的对象上使用memset�Q�或者memcpy�Q�。如果一个对象需要memset�Q�那么在该对象的构造函数里面memset自己。如果你需要memset一个对象数�l�，那也在该对象的构造函数里面memset自己�?span style="COLOR: red">如果你需要memset一个没有构造函数的复杂对象�Q�那么请��Z��d��一个构造函敎ͼ�除非那是别�h的API提供的东�?/strong>�?br>    4、如果一个对象是�l�承了其他东西，或者某些成员被标记了virtual的话�Q�绝对不要memset。对象是独立的，也就是说父类内部�l�构的演变不需要对子类负责。哪天父�c�里面加了一个string成员�Q�被子类一memset�Q�就�Ʋ哭无泪了�?br>    5、如果需要�ؓ一个对象定义构造函敎ͼ�那么�q�复制构造函数、operator=重蝲和析构函数都全部写全。如果不惛_��复制构造函数和operator=的话�Q�那么用一个空的实现写在private里面�Q�确保�Q何试图调用这些函数的代码都出现编译错误�?br>    6、如果你实在很喜�ƢC语言的话�Q�那�ȝ��换一个只支持C不支持C++的编译器�Q�全面杜�l�因��用了C++而导致你的C坏掉的情况出现�?br>
    什么是循环引用呢？如果两个对象互相使用一个shared_ptr成员变量直接或者间接指向对方的话，��是循环引用了。在�q�种情况下引用计��C��失效�Q�因为就��外边的shared_ptr全释攑օ�了，引用计数也不会是0的�?br>
    今天��p��到这里了�Q�过几天我高兴的话再写一��箋集，如果我持�l�高兴的话呢……嗯嗯……�?

陈梓�?vczh) 2010-06-22 21:16 发表评论