存档在 2013年3月

35 个你也许不知道的 Google 开源项目

2013年3月17日

Google是支持开源运动的最大公司之一,它们现在总共发布有超过500个的开源项目(大部分都是利用它们的API来完成),本文将列举一些有趣的开源项目,其中很可能有不少你不知道的哦。

 

文本文件处理:

Google CRUSH (Custom Reporting Utilities for SHell)

CRUSH是为命令行或shell scripts处理特定文字数据而制作的一系列工具,这里有指南

C++库和源代码:

Google Breakpad

一个开源的多平台崩溃报告系统。

Google GFlags

Gflags是一个命令行标记的处理库,它可以替代“getopt()”,其内置对C++的支持比如string。指南在此

Google Glog

Glog库可执行应用级的登陆,提供基于C++式的登陆API,可用于Linux、BSD和Windows。指南见此

Google PerfTools

这个工具可让开发创建更强大的应用程序,特别是那些用C++模版开发的多线程应用程序,包括TCMalloc, heap-checker, heap-profiler 和cpu-profiler。指南见此还有这里

Google Sparse Hash

非常节省内存的hash-map。指南见此

Omaha – Google Update

Omaha,也就是Google Update,它可以保证你的软件随时升级到最新版本,目前很多Windows下的Google软件都是用Omaha升级的,包括Google Chrome和Google Earth,当然你也可以用于自己的应用程序。指南看这里还有这里

Protocol Buffers

Protocol Buffers是一种可扩展编码序列数据的方式,Google在几乎所有内部RPC协议和文件格式都使用了Protocol Buffers。指南见此它可以用于很多语言而且被一些IDE所支持,比如NetBeans

互联网:

Google Code Pretiffy

这是一个Javascript模块和CSS文件,它可以让HTML页面里的部分源码高亮显示,支持C/C++, Java, Python, Ruby, PHP, VisualBasic, AWK, Bash, SQL, HTML, XML, CSS, JavaScript, Makefiles和部分Perl,不支持Smalltalk和所有的CAML。例子见此

SpriteMe – easy “CSS spirtes”

SpriteMe使你可以更轻松的创造CSS Sprites(俗称雪碧……)就是把网站要用到的图片都堆在一张图片里,用CSS控制调用哪个区域。它有一个自己的官网在这里

Redacisaurus

Reducisaurus是一个压缩CSS和JS文件的网络服务,基于YUI压缩算法,运行于App Engine。

JaikuEngine

JaikuEngine是一个运行于App Engine的微博系统,由jaiku.com运营。要查看移动客户端的源码可以看这里这里还有介绍

Selector Shell

Selector Shell是一个基于浏览器的测试工具,它可以让你看到CSS在不同浏览器里的样式,用Javascript写的,你可以在这里测试

Google Feed Server

Google Feed Server是一个开源Atom发布协议服务,基于Apache Abdera框架,允许开发者快速为当前数据源(比如数据库)配置feed。指南见这里这里

Melange, the Spice of Creation

这个项目的目标是创建出一个适合开源贡献流程的框架,比如Google Summer of Code TM (GSoC)项目。使用这个框架你就可以用Google App Engine来运行Google Summer of Code项目,和其它类似项目比如Google Highly Open Participation TM Contest和GHOP。指南见此

NameBench

它可以查找最快的DNS服务器给你的电脑用,在Mac OS X、Windows和UNIX系统下都有命令行也有用户界面可以帮你测试,这是Google工程师用20%自由时间写出来的。

Rat Proxy

一个半自动化的大型被动网络应用安全审查工具,专为精确的探测而优化,文档在此

TopDraw

Top Draw是一个图形生成程序,使用简单的文字脚本,基于JavaScript编程语言,Top Draw可以创造出非常复杂和有趣的图形。支持Mac OS 10.5以上系统,使用XCode开发。

etherpad

开源的EtherPad,这是一个基于网络的实时合作文档编辑器,这个项目主要是为了演示代码而开发,帮助那些想在自己服务器部署Etherpad的人使用,这里有如何安装的指南。EtherPad使用JavaScript、Java和Comet服务器来建造实时协作服务。

Chromium

Chromium是开源版的Chrome浏览器,Chromium的目标是建立一个新一代的强大网络应用程序,它与Chrome有很多不同之处。这里有指导如何在Linux上编译Chromium

V8 Google’s open source JavaScript engine

V8是Google的开源JavaScript引擎,用C++写成,用于Chrome浏览器之上。V8使用ECMAScript的ECMA-262第三版可运行于Windows XP、Vista、Mac OS 10.5和使用IA-32或ARM处理器的Linux。V8可独立运行也可嵌入到任何C++程序里使用,这里有指南

Chromium OS

Chromium OS是开源版的Chrome OS操作系统,提供快速、简单而安全的网络体验,源码在此

Android

Android是第一个免费、开源而且可完全自定义的移动平台,提供完整的堆栈:一个操作系统、中间件和重要的一用应用,它包含丰富的API可以让第三方开发者开发出强大的应用程序。

MySQL工具:

Google MySQL Tools

各种管理、维护和改进MySQL数据库性能的工具,由Google编写,包括:

  • mypgrep.py:一个类似pgrep的工具来管理MySQL连接
  • compact_innodb.py:可导出和重载所有表格的密集型innodb数据文件

Google mMAIM

mMAIM的目标是对MySQL的监控和分析更简单,且可以和任何环境整合使用。它可显示主/从同步状态,一些性能状态,可以返回大量“show”命令的状态等等。

其它:

Stressful Application Test (stressapptest)

Stressful Application Test试图让来自处理器和I/O到内存的数据尽量随机化,以创造出模拟现实的环境来测试现在的硬件设备是否稳定,Google就在使用它,现在是Apache 2.0许可,这里有介绍安装向导指南

Pop and IMAP Troubleshooter

它用于诊断并解决客户端到邮件服务器的连接问题。

OpenDuckBill

Openduckbill是一个Linux下简单的命令行备份工具,可用于监视文件/目录在有变化后是否标记为备份,并传输这些变化到本地备份目录、远程NFS导出分卷或是用rsync命令导出到远程SSH服务器。见安装向导

ZXing

ZXing(发音类似Zebra crossing)是Java的开源多格式1D/2D条码图像处理库,目的是使用内置在手机上的摄像头拍照并对条码进行解码,而不必与服务器通讯,它被用于Android系统。这里有向导支持的设备列表

Tesseract OCR Engine

Tesseract OCR引擎是1995年UNLV Accuracy测试的前三名之一,在1995和2006年之间它的进展不大,但依然是当前精度最高的OCR引擎。这个源码可读取二进制、灰阶或彩色图片并输出文字,内置一个TIFF阅读器可读取非压缩的TIFF文件,增加libtiff后也可读取压缩图片。指南问答

Neatx – Open Source NX server

Neatx是一个开源NX服务,类似NoMachine公司商业的NX服务。NX协议比VNX更强大,它们的区别主要在:

  • NX是X11客户端所以不会发送位图
  • NX可兼容X、VNC和Windows版的Remote Desktop
  • NX可缓存数据
  • NX安装简单

另外一个可选的项目可以看看Google的FreeNx

PSVM

它是这个文件的代码,这是一个SVM的“支持所有核心”的版本,可多机并行运行,实例见此

GO

Google开发的新编程语言,谷奥有报道

The Google Collections Library for Java

这是一系列与Java 5以及更高版本有关的库,Google花钱给买过来了。

Google styleguide

每个主流的开源项目都有它自己的向导形式,比如一系列的演示代码。如果这些代码都按照“Style”的形式来演示,会更友好。

 

C++ 实现把非静态成员函数作为回调函数

2013年3月17日
众所周知,C++的类成员函数不能像普通函数那样用于回调,因为每个成员函数都需要有一个对象实例去调用它,主要原因是类的成员函数都隐含了一个this指针。
        通常情况下,要实现成员函数作为回调函数,一种常用的方法就是把该成员函数设计为静态成员函数,但这样做有一个缺点,就是会破坏类的结构性,因为静态成员函数只能访问该类的静态成员变量和静态成员函数,不能访问非静态的,要解决这个问题,需要把对象实例的指针或引用做为参数传给它。
        最近看到了一种方法可以简单的实现回调非静态成员函数,其原理就是把要调用该成员函数的对象实例赋值给一个变量,然后通过该变量来调用成员函数。把逻辑整理了一下,然后写了一个简单的回调代理类,通过这个类,可以简单的实现非静态函数的回调。
        另外只演示了只有一个参数的例子,多参数可以仿照扩增。
<pre>#ifndef __CALLBACK_PROXY_H__ 
#define __CALLBACK_PROXY_H__  

//Tobject:调用对象的类型,Tparam回调函数参数的类型  
template<typename Tobject, typename Tparam>  
class CCallbackProxy  
{  
    typedef void (Tobject::*CbFun)(Tparam*);  
public:  
    void Set(Tobject *pInstance, CbFun pFun);  
    bool Exec(Tparam* pParam);  

private:      
    CbFun       pCbFun;     //回调函数指针  
    Tobject*    m_pInstance;    //调用对象  
};  
//设置调用对象及其回调函数  
template<typename Tobject, typename Tparam>  
void CCallbackProxy<Tobject, Tparam>::Set(Tobject *pInstance , CbFun pFun)  
{  
    m_pInstance = pInstance;   
    pCbFun = pFun;  
};  
//调用回调函数  
template<typename Tobject, typename Tparam>  
bool CCallbackProxy<Tobject, Tparam>::Exec(Tparam* pParam)  
{  
    (m_pInstance->*pCbFun)(pParam);  
    return true;  
}  
#endif</pre>

下面演示下如何使用该类

<pre>#include "CallbackProxy.h"  
class CTest  
{  
public:  
    CTest(int nNum);  
    void CbPrintSum(int *pnAddNum){printf("The Sum is %d\n", m_nSum+*pnAddNum);};  
private:  
    int m_nSum;  
};  
int main(int argc,  char* argv[])  
{  
    CCallbackProxy<CTest, int> CbProxy;  
    CTest TestInstance(20);  
    CbProxy.Set(&TestInstance, &CTest::CbPrintSum);  
    int nNum = 1000;  
    CbProxy.Exec(&nNum);  
    return 0;  
}  
CTest::CTest(int nNum): m_nSum(nNum)  { }</pre>

ofstream、ifstream、fstream使用总结[1]

2013年3月17日

ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间;

在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:

1、插入器(< < )
向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout< < ” Write Stdout” < < ‘\n’; 就表示把字符串” Write Stdout” 和换行字符(‘\n’)输出到标准输出流。

2、析取器(> > )
从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin> > x; 就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。

一、打开文件
在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:

void open(const char* filename,int mode,int access);

参数:

filename:  要打开的文件名
mode:   要打开文件的方式
access:  打开文件的属性

打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下:

ios::app:   以追加的方式打开文件
ios::ate:   文件打开后定位到文件尾,ios:app就包含有此属性
ios::binary:  以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文
ios::in:    文件以输入方式打开(文件数据输入到内存)
ios::out:   文件以输出方式打开(内存数据输出到文件)
ios::nocreate: 不建立文件,所以文件不存在时打开失败
ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败
ios::trunc:  如果文件存在,把文件长度设为0

可以用“或”把以上属性连接起来,如ios::out|ios::binary

打开文件的属性取值是:

0:普通文件,打开访问
1:只读文件
2:隐含文件
4:系统文件

可以用“或”或者“+”把以上属性连接起来 ,如3或1|2就是以只读和隐含属性打开文件。

例如:以二进制输入方式打开文件c:\config.sys
fstream file1;
file1.open(” c:\\config.sys” ,ios::binary|ios::in,0);

如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:
file1.open(” c:\\config.sys” ); < => file1.open(” c:\\config.sys” ,ios::in|ios::out,0);

另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:
fstream file1(” c:\\config.sys” );

特别提出的是,fstream有两个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。
ifstream file2(” c:\\pdos.def” ); //以输入方式打开文件
ofstream file3(” c:\\x.123″ ); //以输出方式打开文件

所以,在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定义。

二、关闭文件
打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close(); 就把file1相连的文件关闭。

三、读写文件
读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就可以了;而对于二进制的读取就要复杂些,下要就详细的介绍这两种方式

1、文本文件的读写
文本文件的读写很简单:用插入器(< < )向文件输出;用析取器(> > )从文件输入。假设file1是以输入方式打开,file2以输出打开。示例如下:

file2< < ” I Love You” ; //向文件写入字符串” I Love You”
int i;
file1> > i; //从文件输入一个整数值。

这种方式还有一种简单的格式化能力,比如可以指定输出为16进制等等,具体的格式有以下一些

操纵符 功能 输入/输出
dec 格式化为十进制数值数据 输入和输出
endl 输出一个换行符并刷新此流 输出
ends 输出一个空字符 输出
hex 格式化为十六进制数值数据 输入和输出
oct 格式化为八进制数值数据 输入和输出
setpxecision(int p) 设置浮点数的精度位数 输出

比如要把123当作十六进制输出:file1< < hex< < 123; 要把3.1415926以5位精度输出:file1< < setpxecision(5)< < 3.1415926。

2、二进制文件的读写
①put()
put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put(‘c’); 就是向流写一个字符’c’。

②get()
get()函数比较灵活,有3种常用的重载形式:

一种就是和put()对应的形式:ifstream &get(char & ch); 功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x); 表示从文件中读取一个字符,并把读取的字符保存在x中。

另一种重载形式的原型是: int get(); 这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get(); 和上例功能是一样的。

还有一种形式的原型是:ifstream &get(char *buf,int num,char delim=’\n’);这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符’\n’。例如:

file2.get(str1,127,’A’);     //从文件中读取字符到字符串str1,当遇到字符’A’或读取了127个字符时终止。

③读写数据块
要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:

read(unsigned char *buf,int num);
write(const unsigned char *buf,int num);

read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount(); 来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。

例:

unsigned char str1[]=” I Love You” ;
int n[5];
ifstream in(” xxx.xxx” );
ofstream out(” yyy.yyy” );
out.write(str1,strlen(str1)); //把字符串str1全部写到yyy.yyy中
in.read((unsigned char*)n,sizeof(n)); //从xxx.xxx中读取指定个整数,注意类型转换
in.close(); out.close();

四、检测EOF
成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();

例:  if(in.eof())    ShowMessage(” 已经到达文件尾!” );

五、文件定位
和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是seekg()和seekp()。seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:

istream &seekg(streamoff offset,seek_dir origin);
ostream & seekp(streamoff offset,seek_dir origin);

streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的基准位置,是一个有以下值的枚举:

ios::beg:  文件开头
ios::cur:  文件当前位置
ios::end:  文件结尾

这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。例:

file1.seekg(1234,ios::cur);     //把文件的读指针从当前位置向后移1234个字节
file2.seekp(1234,ios::beg);     //把文件的写指针从文件开头向后移1234个字节

举例:

如果想使用流来存入整数,然后读取整数

1.以追加的方式在文件末端添加整数


#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>
using namespace std;

int main()
{
 ofstream file2("file.txt",ios::app);
 int i = 9999;
 file2<<i;
 file2.close();
}


#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>
using namespace std;

int main()
{
 ofstream file2("file.txt",ios::app);
 for(int i = 0; i<= 10; ++i)
 {
 file2<<i;
 file2<<" ";
 }
 file2.close();

ifstream file1("file.txt");
 int result;
 while(!file1.eof())
 {
 file1>>result;
 cout<<result<<endl;
 }
 file1.close();
 exit(0);
}

这个例子就是在文件中写入整数,然后再以整数读出的一个例子。

理论分析类的超前引用

2013年3月17日

可以声明一个类而不定义它
class Screen;
这个声明,有时候被称为前向声明(forward declaration),在程序中引入了类类型的Screen.在声明之后,定义之前,类Screen是一个不完全类型(incompete type),即已知Screen是一个类型,但不知道包含哪些成员.
不完全类型只能以有限方式使用,不能定义该类型的对象,不完全类型只能用于定义指向该类型的指针及引用,或者用于声明(而不是定义)使用该类型作为形参类型或返回类型的函数.

对于C++中,类的定义之前声明它,如下实例代码:

class B;

class A{

//…………………………

B * ptr_B;.

};

class B{

//………………..

};

被提前声明的类在其定义之前,只能使用该类的指针或者引用 。

在类的定义结束(编译器在遇到类定义的右花括号之后),用该类来声明类实例对象,或对象指针,引用都是合法的。

所谓超前引用是指一个类型在定义之前就被用来定义变量和声明函数。
一般情况下,C/C++要求所有的类型必须在使用前被定义,但是在一些特殊情况下,这种要求无法满足,例如,在类CMyView中保留了一个非模式对话框对象指针,该对象用于显示/修改一些信息。为了实现对话框“应用”按钮,把对话框做的修改立刻更新到view界面上,为此,需要在对话框类中需要保存view类的指针,这样定义关系就变成如下的代码:

<pre>#ifndef __MYVIEW_H__
 #define __MYVIEW_H__
 //这是view类的头函数
 #include "MyDialog.h"
 class CMyView::public CView
 {
 protected:
     CMyDialog * pDlg;
     //这里是其他定义
 };
 #endif

 #ifndef __MYDIALOG_H__
 #define __MYDIALOG_H__
 //这是对话框类的定义
 #include "MyView.h"
 class CMyDialog::public CDialog
 {
     protected:
         CMyView * pView;
         //其他定义
 };
 #endif</pre>

从编译器角度看,编译MyDialog.CPP时,系统首先定义宏__MYDIALOG_H__,然后包含MyView.h,MyView.h中的#include “MyDialog.h”由于__MYDIALOG_H__已经定义,所以不再起作用。在CMyView类的声明中, CMyDialog* pDlg ;就会让编译器产生“CMyDialog”类型没有定义之类的错误,编译MyView.CPP文件出现的错误可以类似得到。
更一般的情况,类A和类B需要彼此互相引用,这样必然有一个类会先被定义,而另外一个类后被定义,这样在先被定义的类引用后被定义的类的时候,就导致了所谓的超前引用。
超前引用导致的错误有以下几种处理办法:
1) 使用类声明
在超前引用一个类之前,首先用一个特殊的语句说明该标识符是一个类名,即将被超前引用。其使用方法是:
a)  用class ClassB;声明即将超前引用的类名
b)  定义class ClassA
c)  定义class ClassB;
d)  编制两个类的实现代码。
上述方法适用于所有代码在同一个文件中,一般情况下,ClassA和ClassB分别有自己的头文件和cpp文件,这种方法需要演变成:
a) 分别定义ClassA和ClassB,并在cpp文件中实现之
b) 在两个头文件的开头分别用class ClassB;和class ClassA;声明对方
c) 在两个cpp文件中分别包含另外一个类的头文件
NOTE:这种方法切记不可使用类名来定义变量和函数的变量参数,只可用来定义引用或者指针。

2) 使用全局变量
由于全局变量可以避免超前引用,不用赘述。我的习惯是,把类对象的extern语句加在该类头文件的最后,大家喜欢怎样写那都没有什么大问题,关键是保证不要在头文件中胡乱包含。
3) 使用基类指针。
这种方法是在引用超前引用类的地方一律用基类指针。而一般情况下,两个互相引用的类并不涉及其基类,因此不会造成超前引用。以开始的例子说:在CMyDialog类中用CView*代替CMyView*,CMyView类中用CDialog*代替CMyDialog*,这样必然不会造成超前引用。

C++中类的前向声明与超前引用

2013年3月17日

在项目中机器人类Robot与路径规划类RobotPathPlan之间存在互相引用的情况。Robot中希望能够直接调用RobotPathPlan中的成员函数来设置机器人路径规划的目标位置。RobotPathPlan类又希望能够直接使用Robot中的成员函数来获取超声波传感器数据。

(以下的类只是举例,省略了无关函数)

比如如下的使用则是错误:
Robot.h
<pre>#ifndef _ROBOT_
#define _ROBOT_
#include "RobotPathPlan.h"

class Robot
{
private:
	int sonarDist[16];
	RobotPathPlan *pathPlan;
public:
	Robot()
	{
		pathPlan = new RobotPathPlan(this);
		for(int i = 0; i < 16; ++i)
			sonarDist[i] = i+1;
	}
	~Robot()
	{
		delete pathPlan;
		pathPlan = NULL;
	}
	void start()
	{
		int	result =	pathPlan->fire();
	}
	int getSonar(int i) const
	{
		return sonarDist[i];
	}
};
#endif</pre>

RobotPathPlan.h

<pre>#ifndef _PATH_
#define _PATH_
#include "Robot.h"

class RobotPathPlan
{
private:
	Robot *robot;
public:
	RobotPathPlan(Robot* t_robot) : robot(t_robot) {}
	int fire()
	{
		return robot->getSonar(5);
	}
};
#endif</pre>

main.cpp

<pre>#include <iostream>
#include "Robot.h"
#include "RobotPathPlan.h"
using namespace std;

int main()
{
	Robot myRobot;
	myRobot.start();
}</pre>
提示错误:
<pre>In file included from Robot.h:3:0,
                 from main.cpp:2:
RobotPathPlan.h:8:2: 错误:‘Robot’不是一个类型名
RobotPathPlan.h:10:21: 错误:expected ‘)’ before ‘*’ token
RobotPathPlan.h: 在成员函数‘int RobotPathPlan::fire()’中:
RobotPathPlan.h:13:10: 错误:‘robot’在此作用域中尚未声明
In file included from main.cpp:2:0:
Robot.h: 在构造函数‘Robot::Robot()’中:
Robot.h:14:36: 错误:对‘RobotPathPlan::RobotPathPlan(Robot* const)’的调用没有匹配的函数
RobotPathPlan.h:6:1: 附注:备选为: RobotPathPlan::RobotPathPlan()
RobotPathPlan.h:6:1: 附注:         RobotPathPlan::RobotPathPlan(const RobotPathPlan&)</pre>
很明显:Robot RobotPathPlan互相引用,所以导致Robot不是一个类名。
如果将上边的:#inculde “Robot.h”与#include”RobotPathPlan.h”分别该为前向引用。class Robot,class RobotPathPlan则会出现如下错误。
<pre>In file included from main.cpp:2:0:
Robot.h: 在构造函数‘Robot::Robot()’中:
Robot.h:13:36: 错误:对不完全的类型‘struct RobotPathPlan’的非法使用
Robot.h:4:7: 错误:‘struct RobotPathPlan’的前向声明
Robot.h: 在析构函数‘Robot::~Robot()’中:
Robot.h:19:10: 警告:检测到调用 delete 运算符时可能出现的问题:
Robot.h:19:10: 警告:对不完全的类型‘struct RobotPathPlan’的非法使用
Robot.h:4:7: 警告:‘struct RobotPathPlan’的前向声明
Robot.h:19:10: 附注:析构函数和类特定的 delete 运算符均不会被调用,即使它们在类定义时已经声明。
Robot.h: 在成员函数‘void Robot::start()’中:
Robot.h:24:24: 错误:对不完全的类型‘struct RobotPathPlan’的非法使用
Robot.h:4:7: 错误:‘struct RobotPathPlan’的前向声明</pre>
这是因为C++中,声明而未定义的对象只能用来定义指针和引用。 还可以作为函数声明(不是定义)的参数和返回值。
需要做如下调整:
在Robot类的定义中要让RobotPathPlan的大小和成员都不可见。
在RobotPathPlan类的定义中要让Robot的大小和成员不可见。
也即是不能使用对方的成员函数,不能定义除了指针,引用以外的其他类型(不能定义对象),不能释放指针。
只有增加两个源文件:Robot.cpp,RobotPathPlan.cpp
Robot.h
<pre>#ifndef _ROBOT_
#define _ROBOT_
class RobotPathPlan;
class Robot
{
private:
	int sonarDist[16];
	RobotPathPlan *pathPlan;
public:
	Robot();
	~Robot();
	void start();
	int getSonar(int i) const
	{
		return sonarDist[i];
	}
};
#endif</pre>

Robot.cpp

<pre>#include "Robot.h"
#include "RobotPathPlan.h"
#include <iostream>
void Robot::start()
{
	int	result =	pathPlan->fire();
	std::cout<<result<<std::endl;
}
Robot::Robot()
{
	pathPlan = new RobotPathPlan(this);
	for(int i = 0; i < 16; ++i)
		sonarDist[i] = i+1;
}
Robot::~Robot()
{
	delete pathPlan;
	pathPlan = 0;
}</pre>

RobotPathPlan.h

<pre>#ifndef _PATH_
#define _PATH_
class Robot;
class RobotPathPlan
{
private:
	Robot *robot;
public:
	RobotPathPlan(Robot* t_robot) : robot(t_robot) {}
	int fire();
};
#endif</pre>

RobotPathPlan.cpp

<pre>#include "Robot.h"
#include "RobotPathPlan.h"
int RobotPathPlan::fire()
{
	return robot->getSonar(5);
}</pre>

现在来观察,类的定义中(.h文件)里除了指针和引用外已经没有出现对象定义,函数调用之类的语句。

如何使用前置声明取代包括头文件减少编译依赖

2013年3月17日

在这里,我自己总结了可以使用前置声明来取代包括头文件的各种情况和给出一些示例代码。

首先,我们为什么要包括头文件?问题的回答很简单,通常是我们需要获得某个类型的定义(definition)。那么接下来的问题就是,在什么情况下我们才需要类型的定义,在什么情况下我们只需要声明就足够了?问题的回答是当我们需要知道这个类型的大小或者需要知道它的函数签名的时候,我们就需要获得它的定义。

假设我们有类型A和类型C,在哪些情况下在A需要C的定义:

  1. A继承至C
  2. A有一个类型为C的成员变量
  3. A有一个类型为C的指针的成员变量
  4. A有一个类型为C的引用的成员变量
  5. A有一个类型为std::list<C>的成员变量
  6. A有一个函数,它的签名中参数和返回值都是类型C
  7. A有一个函数,它的签名中参数和返回值都是类型C,它调用了C的某个函数,代码在头文件中
  8. A有一个函数,它的签名中参数和返回值都是类型C(包括类型C本身,C的引用类型和C的指针类型),并且它会调用另外一个使用C的函数,代码直接写在A的头文件中
  9. C和A在同一个名字空间里面
  10. C和A在不同的名字空间里面

下面对各条的详细分析:
1,没有任何办法,必须要获得C的定义,因为我们必须要知道C的成员变量,成员函数。

2,需要C的定义,因为我们要知道C的大小来确定A的大小,但是可以使用Pimpl惯用法来改善这一点,详情请
看Hurb的Exceptional C++。

3,4,不需要,前置声明就可以了,其实3和4是一样的,引用在物理上也是一个指针,它的大小根据平台不同,可能是32位也可能是64位,反正我们不需要知道C的定义就可以确定这个成员变量的大小。

5,不需要,有可能老式的编译器需要。标准库里面的容器像list, vector,map,
在包括一个list<C>,vector<C>,map<C, C>类型的成员变量的时候,都不需要C的定义。因为它们内部其实也是使用C的指针作为成员变量,它们的大小一开始就是固定的了,不会根据模版参数的不同而改变。

6,不需要,只要我们没有使用到C。

7,需要,我们需要知道调用函数的签名。

8,8的情况比较复杂,直接看代码会比较清楚一些。

分解大量switch-case分支

2013年3月17日

项目经过长期多人的维护,所谓人多手杂,出现不少过多过长的switch-case分支,或者多重switch-case嵌套。每每添加功能,我都会紧皱眉头,然后带着罪恶感向已经成百上千行的函数里再添上一个case分支,然后纠结地收工了事。

于是乎,在我的内心深处,switch-case俨然成了代码坏味道的代名词,写代码时总小心翼翼地避开它们,可往往又事与愿违。

事实上,switch-case语句并不是代码坏味道的根源,坏味道来自糟糕的结构设计,过多的switch-case分支,多重switch-case嵌套,这些都将导致代码可读性下降,维护困难易出错。

对于分支有多又长的switch-case分支,可是使用表驱动方法或者在特定情况下可以采用表驱动方法结合事件机制进行分解。

对于表驱动方法,可用数组或std::map将case判定常量映射到相应的处理函数。核心代码实现类似如下:

// 分支判定枚举
enum CASE
{
_CASE_A,

_CASE_X,
_CASE_AMOUNT // 分支总数
};

// 处理函数类型
typedef void (*HANDLER)(void);

// 映射
HANDLE handlers[_CASE_AMOUNT] =
{
&HandlerA,

&HandlerX
};

bool handler(UINT uEvent)
{
if (uEvent < _CASE_AMOUNT)
{
(*handlers[uEvent])();
return true;
}
return false;
}

优点:条理清晰易于阅读。
缺点:要增添很多处理函数,且不便于跟踪调试。

对于在一个公共对象里使用switch-case分支集中处理大量与该对象无紧密逻辑关联事件的情况。可通过在公共基类中使用事件处理机制,实现事件与监听器(与事件相关的对象,如窗口)的映射,事件的分配处理。相关代码如下:

class CBase
{

public:
// 添加事件监听器
static bool AddEventListener(UINT uEvent, CBase* pListener);

// 移除事件监听器
static bool RemoveEventListener(UINT uEvent, CBase* pListener);

// 将事件给相应监听器处理
static void DispatchEvent(UINT uEvent);

// 处理事件,该虚函数由监听器实现
virtual void OnEvent(UINT uEvent, int nParam) {}

private:
// 事件与监听器的映射,多个监听器可监听同一个事件
static std::multimap<UINT, CBase*> m_mmapEventListener;

}

对于事件处理机制,在Java等语言中有大量使用,这里就不贴一大段代码了。

优点:逻辑性强,耦合度低,符合开放封闭原则。
缺点:事件分配时效率较switch-case分支低。

C++中定位new

2013年3月17日

还是先看代码,然后分析。

template <class T1,class T2>
void construct (T1 *p,const T2 &value)
{
	new(p)T1(value);
}

construct 函数模板负责在给定的内存位置构造对象,并同时以某个初始值来初始化它,这里new操作符的形式成为定位new(placement new),这种形式的new并不为新对象分配内存,而只不过是将新对象放置到p所指的内存位置,任何以这种方式new出来的对象都应当通过显式调用其析构函数来撤消,而不是使用delete。

    常常有人问这样一个C++问题:如何在预先定义的内存位置构造一个对象?在预先定义的内存缓冲构造一个对象有许多有用的应用。例如,一个定制的垃圾搜集器能使用一个大的预
分配内存缓冲,用户在这个缓冲中构造其对象。当不再需要这些对象时,它们的存储空间被自动收回。这个技术在重视时间的应用中也很有用。在预先分配的内存缓冲构造一个对象是一种“时间常量”操作,之所以这样说是因为程序分配操作本身不会浪费宝贵的时间。同时也要注意当系统没有足够的内存时,动态内存分配可能失败。因此,对于重视任务的应用,预先分配一个足够大的缓冲有时是不可避免的。

许多应用需要在给定的时间构造不同类型的对象。想一想这样一个例子,一个GUI应用根据用户的输入,每次、显示不同的对话框,利用重复分配和释放内存,这个应用能提前创建一个内存缓冲,并能在这个缓冲里反复构造和销毁不同类型的对象。

C++提供了几种特点来方便实现在预先决定的内存位置构造一个对象的任务。在这些特点中,包括一个特殊形式的new操作符,叫做“定位new”(placement new)操作,以及一个显式的析构处理。实现方法如下:

第一步:分配一个足够的内存缓冲区,以便存放给定类型的对象。如果想要每次构造不同类型的对象,需要至少以最大的对象所占空间的大小分配一个缓冲。预分配的缓冲是在可用内存空间中分配的纯字符数组。

char * buff = new char [sizeof (Foo) ];

一旦分配了缓冲,就能在缓冲中构造每一种类型的对象。为此,使用特殊版本的new操作符(“定位new”),以缓冲地址为placement new的参数。为了使用placement new,必须包含标准头文件<new>。下面的代码片断中,使用placement new操作在内存地址buff上构造类型为Foo的对象。

#include <new>
Foo * pfoo = new (buff) Foo; //使用new操作在buff上构造一个 Foo

Placement new 以先前分配的缓冲(buff)地址作为参数,并在这个缓冲上构造给定类型的对象。他返回构造对象的指针,这个对象指针的使用与通常的指针使用没什么两样。

unsigned int length = pfoo->size(); 

pfoo->resize(100, 200);
length = pfoo->size(); 

当不再需要这个对象的时候,必须显式调用其析构函数释放空间。做这件事是有一些技巧的,因为许多人错误地假设对象会被自动销毁,错也!。在预分配的缓冲里构造另一个对象之前或者在释放缓冲之前,如果忘了显式调用析构函数,程序将产生不可预料的后果。显式的析构器声明如下:

pfoo->~Foo(); //显式调用析构函数

换句话说,一个显式的析构器与普通的成员函数调用一样,只是名字与普通的成员函数稍有差别。一旦对象被销毁,便可以在预分配的内存中再次构造另一个对象。实际上,这个过程可以无限制地重复:构造一个对象,销毁它,然后又反复利用预分配的缓冲构造新对象。

当不再需要预定义的缓冲时,或者说当应用程序关闭时,必须释放预定义的缓冲。使用delete[]完成这个任务,因为预定义的缓冲是一个字符数组。下列代码包含一个完整的例子的所有步骤,包括最终缓冲的释放:

#include <new>
void placement_demo()
{
    //1. 预分配缓冲
    char * buff = new char [sizeof (Foo) ];
    //2. 使用 placement new
    Foo * pfoo = new (buff) Foo;
    //使用对象
    unsigned int length = pfoo->size();
    pfoo->resize(100, 200);
    //3. 显式调用析构函数
    pfoo->~Foo();
    //4. 释放预定义的缓冲
    delete [] buff;
}