C++博客-(define (cuigang) (coding))-随笔分类-C/C++

数组类型、函数类型到左值和右值的转换

cuigang — Mon, 07 Apr 2008 14:50:00 GMT

摘要: 1、左值和右值

表达式的左值是它的地址，右值是该地址所存储的内容。比如下面代码：

x = x + 1;

这两个 x 有什么不同呢？阅读全文

cuigang 2008-04-07 22:50 发表评论

对数组名取地址是什么？

cuigang — Fri, 04 Apr 2008 12:06:00 GMT

摘要: 这两天有人问以下有什么代码有什么不同？

1 int array[100];
2
3 memset(array, 0, sizeof(array));
4 memset(&array, 0, sizeof(array)); 阅读全文

cuigang 2008-04-04 20:06 发表评论

再论Singleton

cuigang — Thu, 20 Dec 2007 13:55:00 GMT

记得以前大家讨论过Singleton三种写法的优劣，今天我又发现了一个新问题，在这里和大家分享一下。下面是三种Singleton的写法： 
 1 // 1st
 2 class Singleton{
 3     static Singleton inst;
 4 public:
 5     Singleton& GetInst(){
 6         return inst;
 7     }
 8 };
 9 Singleton Singleton::inst;
10 // 2nd
11 class Singleton{
12     static Singleton* _inst;
13 public:
14     Singleton& GetInst(){
15         if(_inst == NULL)
16             _inst = new Singleton;
17         return *_inst;
18     }
19 };
20 // 3rd
21 class Singleton{
22 public:
23     Singleton& GetInst(){
24         static Singleton inst;
25         return inst;
26     }
27 }

我们已经知道方法1没有多线程问题，但编译时分配内存。方法2有多线程问题，在运行时分配内存。方法3也有多线程问题，而且在编译时分配内存，但在运行时调用构造函数。（多线程问题的解决方法在此不再赘述。）

那么，我们可能就认为方法1虽然在编译时分配内存，但我们不在乎这点内存，反正写出来是要用的，这点内存少不了，既避免了多线程，又避免了分配失败。就用它了！
不幸的是，方法1也有它自身的问题。今天我在构造一个对象工厂时，期望通过全局变量，向工厂注册派生类的生成方法时，方法1暴露了它的问题。比如我们在Singleton中有一个方法RegisterMethod(CallBack*)，那么我可能这样实现。
 
1 //以下代码是全局的，文件级作用域
2 
3 namespace{
4     CBase* CreateDeriveObj()
5     {
6         return new(CDerive);
7     }
8     BOOL tmp = Singleton::GetInst().RegisterMethod(CreateDeriveObj);
9 }//end of namespace
 
结果发现在调用RegisterMethod()时，Singleton::inst 还没有初始化（构造函数没有被调用）。究其原因是编译器虽然在编译时对其分配内存，但是构造函数是在运行时，在Main()函数前调用。而对于全局变量，编译器是不保证初始化顺序的！而这个例子就是tmp在构造时， Singleton::inst 还没有构造。
而这个问题的解决方法只有使用方法2或者方法3，考虑到我们不能在Main函数前使用new操作符，我用了方法3。又因为我有全局变量保证，就可以不考虑多线程问题了。
要么是这个问题，要么是那个问题，你总要解决一个问题。
 

cuigang 2007-12-20 21:55 发表评论

final 加强

cuigang — Mon, 17 Dec 2007 13:37:00 GMT

在我的旧文中，曾经提到在 C++ 中实现 Java 的 final 功能，但每次都要写一个基类比较麻烦，今次用模板把它加强。

1 template<class T>
2 class final{
3         friend T;
4 private:
5         final(){};
6 };
7
8 class MyTest : public virtual final<MyTest>{
9 public:
10         MyTest(){};
11 };

这样以后就可以直接继承模板类 final，而不用每次都写一个类。

在这里顺便说一下，为什么一定要虚继承，假设我们有

1 class test : public MyTest{};

如果上面不是虚继承，那么 final 类的构造函数由 MyTest 的构造函数负责调用，因为是友元类，则调用成功，无法阻止 test 实例化。而一旦声明为虚继承，MyTest 不再负责调用 final 的构造函数，而由 test 来调用，那么因为不是友元类，实例化将失败，编译出错，提示不能访问私有的构造函数。

cuigang 2007-12-17 21:37 发表评论

对数据访问类型限制的一个方法(尝试)

cuigang — Mon, 17 Dec 2007 13:36:00 GMT

这里给出一个方法，实现对某个方法调用者的限制。

1 class TestBase{
2         int     data;
3 protected:
4         void write(){};
5 public:
6         void read(){};
7 };
8
9 class Test:public TestBase{
10         friend class client;
11 };
12
13 Test test;
14 TestBase test2;
15
16 class client{
17 public:
18         void dowith(){
19                 test.write();
20                 //test2.write();
21         };
22 };
23 //-----------
24 int main()
25 {
26         client c;
27         c.dowith();
28         return 0;
29 }

这里将写方法声明为保护的，对外界不可访问。派生类Test的作用仅仅是将友元类进行声明。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
妙妙妙！
使用这个方法，就可以对类的私有函数进行单元测试了！！！！
JeansBer

cuigang 2007-12-17 21:36 发表评论

空对象模式

cuigang — Mon, 17 Dec 2007 13:34:00 GMT

Martin Flower在《重构》里提到空对象模式，对于从容器中查找失败需要返回引用时，可以使用，同时我觉的对于空指针调用也有一定作用，试举一例：

 1 #include <iostream>
 2  
 3 class Mail{
 4 public:
 5         virtual void print()
 6                   {std::cout<<"Hello!"<<std::endl;};
 7         void* operator new(size_t);
 8 };
 9  
10 class NullMail{
11         NullMail(){};
12         static NullMail inst;
13 public:
14         virtual void print(){
15                 using namespace std;
16                 cout<<"error! You can't access a NULL object!"<<endl;
17         }
18         static NullMail&  GetInst(){return inst;};
19 };
20 
21 NullMail NullMail::inst;
22  
23 void* Mail::operator new(size_t){
24         return &NullMail::GetInst();
25 }
26  
27 Mail*   GetMailPtr(){
28         return NULL;
29 }
30  
31 Mail&   GetMailRef(){
32         return (Mail&)NullMail::GetInst();
33 }
34  
35 //
36  
37         Mail*   ptr_Mail = GetMailPtr();
38         Mail&   ref_Mail = GetMailRef();
39         //ptr_Mail->print();
40         ref_Mail.print();

当我们返回一个空指针给调用者，如果他没有判断，那就会发生系统崩溃，而我们返回一个空对象的引用就可以避免这一点。

另外一个附加的有趣现象，你认为下面的调用会输出什么信息？

1 
2         ptr_Mail = new Mail;
3         ptr_Mail ->print();
4         ref_Mail.print();   

正确的答案是：

1         Hello!
2         Hello!

因为Mail的缺省构造函数将自己的vptr填给了NullMail单例。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
一个问题，是不是Mail的每个公共接口，NullMail都要去实现一下？－－th

//除非实在没有必要，的确应当实现一下所有的公有虚方法。cuigang，2007-11-08

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
“对于从容器中查找失败需要返回引用时”，下午刚刚碰到一个这样的问题。 jb

cuigang 2007-12-17 21:34 发表评论

雕虫小技几则

cuigang — Mon, 17 Dec 2007 13:31:00 GMT

昨天看了一下除颤的代码，发现里面类的框架里有一个NoCopy（类似名字）的类，将拷贝构造函数和赋值运算符声明为私有的，那么继承于这个类的派生类也不能被克隆，注释中强调要私有继承，其实如何继承都可以，只要派生类不在public部分重新定义拷贝构造函数和赋值运算符就可以，另外也不必单独写一个类，这个声明写到基类就可以了。

看到这个我又想到一些类似的小技巧，比如单件模式，其实就是将缺省构造函数声明为私有，以限制实例化。例如还有：

1、强制必须动态分配，可以将析构函数声明为私有，同时提供free方法（因为不能delete）。

2、禁止动态分配，将new方法声明为私有。

3、禁止继承，继承一个类（最好虚继承），这个类的构造函数是私有的，并且它的友元类是派生类。这个比较复杂，代码示例如下

class final{
        friend class MyTest;
private:
        final(){};
};
class MyTest : public virtual final{
public:
        MyTest(){};
};

这样就实现了Java的Final功能。

cuigang 2007-12-17 21:31 发表评论

一个问题的讨论

cuigang — Mon, 17 Dec 2007 13:30:00 GMT

一个问题的讨论

今天在QQ里跟大家讨论了一个问题，虽然没有结论，但是还是贴出来留个记号。

崔刚(崔刚) 2007-10-25 16:18:55
如何通过基类指针调用派生类特有方法，前提是不允许强制转换指针类型？
例如有基类 class base{};
派生类
class derive:public base{
public:
        int A();
}
我得到了一个base* 类型的指针 derive_ptr，但它指向derive类型对象，我如何调用方法 derive::A(), 不可以
((derive*)derive_ptr)->A();
李奇兵(李奇兵) 2007-10-25 16:20:17
把方法A（）申明为虚的
陶华(陶华) 2007-10-25 16:20:52
除非基类有这个虚接口
李奇兵(李奇兵) 2007-10-25 16:20:55
把方法A（）申明为虚的，在Base定义一个。
向官文(向官文) 2007-10-25 16:21:16
用函数指针应该可以实现吧
陈道生(陈道生) 2007-10-25 16:22:46
没方法
崔刚(崔刚) 2007-10-25 16:22:27
呵呵，如果base类有几十个派生类，每个派生类都有不同的特有方法，那么在基类中就会存在几十个虚方法，而每个派生类只实现一个，其它全部不实现，
这样是不是不太好？？
李伟(监护）(李伟(监护）) 2007-10-25 16:23:25
如果是public的，基类应该声明吧
张建生(张建生) 2007-10-25 16:23:57
这样的话该函术确实不应该在基类里面定义
基类里面只定义共有的
靳波(靳波) 2007-10-25 16:23:47
这个问题的答案肯定很有技巧，但我认为这种技巧太花哨，不知道也没关系
陶华(陶华) 2007-10-25 16:24:49
崔刚，你那样定义是违反替换原则的
向官文(向官文) 2007-10-25 16:25:02
咱们的消息映射机制就是用基类的函数指针调派生类的成员函数
李伟(监护）(李伟(监护）) 2007-10-25 16:25:02
还是想知道。。
莫书健(莫书健) 2007-10-25 16:25:22
上面那段代码会不会运行是对的？
只是这样强制转换不是很符合编码规范
崔刚(崔刚) 2007-10-25 16:25:28
呵呵，不要怀疑我的问题的实用性
彭建军(彭建军) 2007-10-25 16:26:34
对于这个问题，C++的标准解决方法应该是dynamic_cast
靳波(靳波) 2007-10-25 16:26:15
cast也是类型转换
莫书健(莫书健) 2007-10-25 16:27:41
加不加dynamic_cast之类的，运行效果应该一样
彭建军(彭建军) 2007-10-25 16:29:18
是类型转换，但那是C++标准的转换方式。
向官文(向官文) 2007-10-25 16:30:45
dynamic_cast 据说会损失执行期效率
靳波(靳波) 2007-10-25 16:31:33
dynamic是在运行时进行转换，所以不是据说，是肯定会损失执行期效率。
靳波(靳波) 2007-10-25 16:36:22
#include "stdafx.h"
#include
using namespace std;
class Base
{
};
class Derive : public Base
{
public:
int A(){cout<< "Derive::A()\n"; return 0;}
};
union Amazing
{
Base* pBase;
Derive* pDerive;
};

int _tmain(int argc, _TCHAR* argv[])
{
Base* derive_prt = new Derive;
Amazing trick;
trick.pBase = derive_prt;
trick.pDerive->A();
delete derive_prt;
return 0;
}
向官文(向官文) 2007-10-25 16:37:45
typedef void (base:: *BasefnPtr) ();
BasefnPtr fn_ptr = &derive::A;
然后用基类的指针去调
(pBase->*fn_ptr)();
我看高端里消息响应函数就这样调
没理解错吧 ;)
崔刚(崔刚) 2007-10-25 16:39:09
同志们，跑题了
1、不能强制转换，标准的强制转换也不行。
2、不是把派生类指针转成基类指针，那样是没问题的。我说的是把基类指针转成派生类指针。
杨晓涛(杨晓涛) 2007-10-25 16:40:14
靳波的方法挺有创意的，呵呵
靳波(靳波) 2007-10-25 16:40:45
：）
莫书健(莫书健) 2007-10-25 16:41:37
jinbo的方法有什么优点？
崔刚(崔刚) 2007-10-25 16:41:46
靳波太搞笑了，这样写不可维护
靳波(靳波) 2007-10-25 16:41:41
这个方法太危险
崔刚(崔刚) 2007-10-25 16:42:13
变相的强制转换，不合格，0分
莫书健(莫书健) 2007-10-25 16:43:34
cuigang的需求估计没有解决方法
陶华(陶华) 2007-10-25 16:44:57
需求评审不通过
崔刚(崔刚) 2007-10-25 16:44:40
问题本身是没有解的，但是迂回的方法有，比如IoControl或者高端中ControlModule的方法就是一种，但是不是有其它更好的办法呢？
崔刚(崔刚) 2007-10-25 16:45:34
visitor 模式也提供了一种方法，但是太麻烦，本质上和 IoControl 没什么区别。
张进(张进) 2007-10-25 16:48:45
还有一种方法,把编译器作者拉出来打,狂打,直到他搞定为止!
陈道生(陈道生) 2007-10-25 16:48:57
有点像已经知道方法名和参数,如何调用实例对应的方法,在c++中无解,在其他语言大放异彩(java,c#),都是要具有元编程能力的语言才行.
崔刚(崔刚) 2007-10-25 16:48:26
我需要一种安全方便又易于维护的办法，不要急着回答
崔刚(崔刚) 2007-10-25 16:49:23
难道我们真的离不开强制转换？？
莫书健(莫书健) 2007-10-25 16:52:18
如果想调用派生类的方法，就要使用虚函数，
设计基类是要充分抽象，尽量想到种种情况
向官文(向官文) 2007-10-25 16:53:01
崔刚好像对强制转换深恶痛绝啊～
崔刚(崔刚) 2007-10-25 16:52:46
我认为依靠继承的方法不可取
莫书健(莫书健) 2007-10-25 16:53:19
实在不行，就将就强制一把，我想也可以容忍的
杨晓涛(杨晓涛) 2007-10-25 16:54:05
类本身也需要细化，寄希望一个类包含所有的接口是不现实的；
粗暴的将所有功能放在一个类中，也是不美观的，不招人喜欢的
崔刚(崔刚) 2007-10-25 16:53:45
不是我厌恶强制而是强制不安全，维护代码时可能发生不可意料的问题。
靳波(靳波) 2007-10-25 16:53:57
既然你已经有答案，不如公布出来让大家参详参详。
崔刚(崔刚) 2007-10-25 16:54:54
我没有答案，有的话就给你们上课了
莫书健(莫书健) 2007-10-25 16:56:11
这个课题就叫“崔刚猜想”吧
陶华(陶华) 2007-10-25 16:58:27
给C＋＋标准委员会提个需求
崔刚(崔刚) 2007-10-25 16:59:27
另，dynamic_case<> 需要编译器支持 RTTI
向官文(向官文) 2007-10-25 17:04:51
C++这门静态语言解决这个执行期的动态问题恐怕无解
也许出路在第三方的接口上吧
崔刚(崔刚) 2007-10-25 17:05:55
换句话说，大家是不是认为，在目前阶段，象ControlModule和IoControl这样的接口是相对合适的喽。
崔刚(崔刚) 2007-10-25 17:13:41
2007年10月8日，汪胜平在他的工作日志里写道：
关于ControlModule型接口
这种类型的接口有以下好处：
1、降低编译依赖性。
2、如果模块A通过接口ControlModule依赖模块B，当模块B不存在时，理论上模块A仍然可以正常工作。
当然它也有一个不好的地方，那就是本来简单的调用关系，因为这个接口的引入变得复杂一些了。
但是，这两个好处需要小心使用才能保证。
1、没有函数名的依赖，但是并不代表就没有编译依赖了。比较典型的是ID的依赖。ID在模块B中被定义。在A中直接包含
B的头文件。不过这种编译依赖可以由第三方定义ID来解决。
2、如果需要传递的信息比较多，我们最容易想到的方法是定义一个结构体来传递相关信息。这个结构体如果由B来定义，
那么A又落入了在编译上依赖B的陷阱。
3、如果A在调用时没有考虑好B不存在怎样处理，那么ControlModule的第二个好处就体现不出来。
对于ControlModule型接口。我觉得要慎用，它不是万能的。某些时候，虚函数也许更方便。
=================================
这是一个典型的C方式函数。我觉得如果是通用的接口，可以用多态，如果是特殊函数，这样写纯属找茬。//崔刚 2007-10-12
=================================
ControlModule这类的接口，简单问题复杂化，难道只是为了
“降低编译依赖性”？这会不会是我们软件部附加上去的想法,
这类接口经常用于驱动接口(请参看linux\windows,
还有我们的mmos驱动模型),
我想最初这样做的理由会不会是这样：
1）为了减少接口个数。
2）统一属性设置/获取接口。
至少在驱动是这样的。
比如：
set_property1();
set_property2();
:
:
set_propertyN();
减少为一个
#define ID_PROPERTY_1 0
#define ID_PROPERTY_2 1
:
:
#define ID_PROPERTY_N n
Control( property_id, ...);
mosj

夏恒星(夏恒星) 2007-10-25 17:37:29
呵呵，原来这样的问题并不只有我遇到，俺在代码中加了注释：
    //注意: 将基类指针强制转换为派生类指针并不可取
    //但是此处要使用协议各层提供的非基类提供的接口
    //能不能从设计上避免?
    mTopProtocol = (CUartCommProtocol* )(m_pProtocolStack->GetSpecifiedLayer(UART_COMM_PROTOCOL));
崔刚(崔刚) 2007-10-25 17:44:02
这种应用更常见的地方是，把不同的派生类放到共同基类类型的指针容器里，然后把这个基类指针取出来，再干一些派生类的事情。
崔刚(崔刚) 2007-10-25 17:46:11
随便在高端里copy一段代码给大家看：
MSpinBox* pSB;
pSB = (MSpinBox*)GetWindowItem(IDC_CO_SPIN_TB_HI);
INT32 value = pSB->GetIntCur();
汪胜平(汪胜平) 2007-10-25 17:53:20
我觉得这种类型的接口比ControlModule强，
虽然这些接口会增加编译期依赖。
崔刚(崔刚) 2007-10-25 17:53:40
这就见仁见智了。
崔刚(崔刚) 2007-10-25 17:58:59
下班前，抄一段《JAVA编程思想》的话给各位共勉，包括发炎的没发炎但吃了药的。
http://vss2/sites/jhsoftware/Lists/List13/Attachments/768/ThinkJava.bmp

$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
太“行而上”了！不过监护软件部真是不可小觑啊！                       张进

/*******************************************/
/*
我不认为这是一个“形而上”的问题，或者一个智力游戏，它有着广泛的用途，否则不会有这么多的讨论和解决方案。昨天晚上回家查了一下，“向下转型”的确是我们要在设计中避免的，但在实际设计却经常面临，目前所有语言基本都支持到dymanicv_case<>的地步，而这却需要RTTI的支持，虽然其他高级语言比如C#，Java，Python都在语言级别提供象“反射”等方式来解决这个问题的超集，但是此种“元类”的语言特性违背了C++的精神，想必无论如何也不会出现在C++里，因为效率的牺牲和运行时存储的需求应该也不适用于目前的嵌入式设备。
反过来再想想，我们何必要求非常安全的途径解决这样的问题。C++/C本来就是一种弱类型语言，不安全的特性比比皆是，所以动态强制转换未必不是一个正途。
另外，对于汪胜平最后说出的问题，我觉得ControlModule之类的写法可以用这种强制转换的方式解决，当然孰优孰劣就留给各位去判别了。
           崔刚 2007-10-26
*/

cuigang 2007-12-17 21:30 发表评论

20070424备忘——仿函数

cuigang — Mon, 17 Dec 2007 13:25:00 GMT

1
2 class functor{
3 public:
4     void operator()(int x){
5     cout<<x<<endl;
6     }
7 };
8
9 int main()
10 {
11     functor func;
12     func(5);
13 }
14

仿函数可以代替函数指针，而且它可以保存状态（类里面含有成员变量），相当于函数指针指向的函数有局部静态变量，同时它可以同时存在多个实例。

cuigang 2007-12-17 21:25 发表评论

20070328备忘

cuigang — Mon, 17 Dec 2007 13:21:00 GMT

1、指向非静态成员函数的指针不是普通的指针，要包含包括this指针等信息，具体取决于编译器的实现。
2、指向虚的非静态的成员函数形成虚调用，指向基类的成员函数的指针可以产生对派生类重载函数的调用，可以实现C＃中的委托。
3、委托？反射？托管？

cuigang 2007-12-17 21:21 发表评论