从C++ std/Boost库迁移到Tango

    本页目的是为了帮助大家从熟知的C++ 库迁移到Tango库。

C++/C 与D 的一般差别

预处理语句

象下面的条件编译会被完全忽略。

#ifndef myclass #define my_class

..

..

#endif

#define语句可以用

const unint foo;

或枚举(经常被推荐用来减小可执行代码的体积)代替。

至于其它#ifndef (之类的)语句，可以用static if 或version。

异常

不要利用异常作为你的程序正常的控制流。例如当你编译代码时加上”-release”标志数组边界检查会去除。

标准C头文件

time.h

为了操作时间，请用tango.util.time包里的各种模块吧。

STL

std::cout

对于简单的控制台输出你有不同的选择，例如：

用tango.io.Console里的

    Cout(“Hello World!”);

仅进行文本输出。

用tango.io.Stdout里的

Stdout.formatln(“Hello {}”, “World”);

进行格式化输出。

●     tango.io.Print也提供了很多有用的函数

●     对于高级日志操作，有tango.util.log（见tutorial）

std::string

D提供了一个内置的类似string的数据类型char[]。它是一个包含字符指针（不是以\0终止的）和长度属性的结构体。Tango提供了包含了高级自付出操作的tango.text.String，尽管它对于基本的字符串操作不是必须的。

std::string::substr

substr的等价物是D核心提供的的切片操作。

std::string::size / std::string::empty

每个数组有个length属性存储了数组的长度。它也是测试数组是否为空最快的方法。

std::find

tango.text.Util有不同于locate*（系列函数） 的功能，不仅能做同样的工作，甚至能做更多的高级操作。

Boost

boost::find

boost::regex

    tango.text.Regex

原文：Transition from C++ std / Boost to Tango

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

最近我发的帖子在群里得到众多高手的细心指点，以及QQ群里热心的老大及时的在线解答和讨论，让我大有所获，故把的解答总结了一下。

1. 除了const,定义常量还有几种方法？
invariant/final/const

2.invariant/const/final 有什么区别？
 
invariant变量不能改变，任何能被invariant变量引用的数据也不能改变。只能用编译期常量来初始化

invariant变量，而且声明和初始化不能分开。invriant变量作为类的成员时不占用空间。

const变量本身不能改变，但数据可以被其它引用改变，其它跟 invariant 相同。

final变量的声明和初始化可以分开，如果在构造函数中，还可以被赋值多次。
http://www.digitalmars.com/d/final-const-invariant.html

3. C++中的引用，在D中怎么表示?如下C++代码，
int i;
int &j = i;
怎么转换成D？

对值类型没有显式引用，但可以用如下代码模拟：
alias i j;

4.
int test(T&); //T是一个类
int test(char&);
如何把这两个函数写成D的形式？

int test(T); //T是一个类
int test(ref char);

类类型默认就是引用

5. 怎么返回一个引用？
比如C++的函数：
string& copy(void);
该怎么写成D 的形式，我曾试图改成
ref string copy(void);
编译器报错

如果是函数要返回引用类型的话,要么用指针,要么把返回值用类包装一下，因为D中类类型总是引用

6. D中没有了sizeof运算符，那计算一个类的大小，该怎么办？
所有类型都有 .sizeof 属性

7. C/C++可以用malloc,new在堆中分配内存，D中对应的是什么呢？
class A
{
}
writefln(A.sizeof);
A pa = new A;

类是透明引用类型，不需要指针。 T obj = new T;

8.类的成员函数貌似只能在类里面定义，不能象C++可以在类的外面实现，是这样吗？
是的

7. in 象C++的默认传值调用，ref相当于C ++的引用，out比ref多了一点东西，就是在调用函数时out参

数都会被设置为默认值，我的理解对否？

D2.0中 in 暗含了 scope；out 是说参数只能写不能读，类似返回值的作用

9.类是透明引用类型，你的意思是D中对类类型默认是引用的，比如：
int test(T t);//T是一个类
这个函数调用是是用引用的吗？而不是象C++那样的传值调用
是的，跟java/C#相同

10. 既然out是只写的，而C++中用const修饰的形参是只读的，D中有没有类似的关键字呢？
比如如下代码：
class T
{
 int i;
};

int test(const T t)
{
         return 0;
}
如何改写成D的形式？

以上代码在D2.0中可以通过编译。此外，D 的 const 是一个storage class，而不是type modifier。

C++还可以用指针去掉const属性，在D中，它把const的变量都看成是ROM，这样真正变成了常量了。C++

中const的类变量是放在内存中的，可以通过指针修改，const只是用来哄编译器的语法糖而已。

11. 数组的dup是浅拷贝还是深拷贝？
浅拷贝：
import std.stdio;

class A
{
     int i = 0;
};

int main(char[][] args)
{

     A[] arrayA = new A[2];
    foreach(ref e; arrayA)
    {
        e = new A();
    }
    for(int i=0; i     {
          writefln(&arrayA[i]);
    }
    printf("\n");
    A[] arrayB = arrayA.dup;
    for(int i=0; i     {
          writefln(&arrayB[i]);
    }
   writefln();

   arrayA[0].i = 9;
   arrayB[0].i = 0;
   writefln(arrayA[0].i);

 return 0;
}
12. const数据可以被非const引用修改
import std.stdio;

class Integer
{
     public int i = 10;
};

int main(char[][] args)
{
     const int i = 10;
     int* j = cast(int*)&i;

     writefln("i = %d",i);
     *j = 20; //temp viriable modified, not the const i
     writefln("i = %d",i);

    const (Integer) si = new Integer();
    writefln("si = %d", si.i);

    Integer* sj = cast(Integer*)&si;
    sj.i = 20;   //modified successfully
    writefln("si = %d", si.i);
    return(0);
}

 感谢群里的高手细心的解答^_^

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

          三篇文章都是牛人写的，看着就过瘾！

PS:争论还在继续，孟岩又有新作，用C设计，用C++编码，刘未鹏则挺C++，Why C++。

一些摘要：

用C设计，用C++编码
C++的心智包袱：
“这样固然是可以work了，但恐怕有更好的方案吧，会是什么呢？...就这样，兜了一个圈子回来。”

“反正现在C和C++都是来做系统级开发，那些华丽的抽象机制用不上，思考解决方案的时候，就以C的方式。注意，C也是可以做基于对 象甚至面向对象甚至组件级别的设计的，但是在C的层面上思考问题，设计能够更精益（lean，现在这是个时髦词），更轻便，更直接。当你构思的设计方案出 来以后，如果其中有些部分，恰好是C++现成做好了，而且使用C++又可以提高开发效率，也没什么明显的副作用，那么就用C++来做相应的部分。”

C的回归：
“没错，我最想说的就是这个。C++ 就是一个“带有一些心智（mental）包袱的语言”。这对软件设计的影响非常之大，没有经年的软件开发实践很难理解这一点。”

“字符串/内存管理根本无关紧要。这不是重要的部分，而且也不复杂。唯一真正重要的部分是设计。”

      原文

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

改这个程序好久，没有头绪，请圈子里的老大给个示范。要保持是Unicode版本，没有黑黑的控制台。

C++代码如下，在Visual Studio 2005下编译通过：

#include <windows.h>
#include <tchar.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain (HINSTANCE hThisInstance,
     HINSTANCE hPrevInstance,
     LPSTR lpszArgument,
     int nCmdShow)
{
 /*  Make the class name into a global variable  */
 TCHAR szClassName[ ] = TEXT("HelloWorld");
 HWND hwnd;               /* This is the handle for our window */
 MSG messages;            /* Here messages to the application are saved */
 WNDCLASSEX wincl;        /* Data structure for the windowclass */

 /* The Window structure */
 wincl.hInstance = hThisInstance;
 wincl.lpszClassName = szClassName;
 wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
 wincl.style = CS_HREDRAW | CS_VREDRAW;    /* Catch double-clicks */
 wincl.cbSize = sizeof (WNDCLASSEX);

 /* Use default icon and mouse-pointer */
 wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
 wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
 wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
 wincl.lpszMenuName = NULL;                 /* No menu */
 wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
 wincl.cbWndExtra = 0;                      /* structure or the window instance */
 /* Use Windows's default colour as the background of the window */
 wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

 /* Register the window class, and if it fails quit the program */
 if (!RegisterClassEx (&wincl))
  return 0;

 /* The class is registered, let's create the program*/
 hwnd = CreateWindowEx (
  0,                   /* Extended possibilites for variation */
  szClassName,         /* Classname */
  TEXT("SDK Verision"),       /* Title Text */
  WS_OVERLAPPEDWINDOW, /* default window */
  CW_USEDEFAULT,       /* Windows decides the position */
  CW_USEDEFAULT,       /* where the window ends up on the screen */
  CW_USEDEFAULT,                 /* The programs width */
  CW_USEDEFAULT,                 /* and height in pixels */
  NULL,        /* The window is a child-window to desktop */
  NULL,                /* No menu */
  hThisInstance,       /* Program Instance handler */
  NULL                 /* No Window Creation data */
  );

 /* Make the window visible on the screen */
 ShowWindow (hwnd, nCmdShow);

 /* Run the message loop. It will run until GetMessage() returns 0 */
 while (GetMessage (&messages, NULL, 0, 0))
 {
  /* Translate virtual-key messages into character messages */
  TranslateMessage(&messages);
  /* Send message to WindowProcedure */
  DispatchMessage(&messages);
 }

 /* The program return-value is 0 - The value that PostQuitMessage() gave */
 return messages.wParam;
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

此贴已经关闭

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

第五章 C++/C程序设计入门

C++标准对main函数有几个不同于一般函数的限制：

（1）不能重载；（2）不能内联；（3）不能定义为静态的；（4）不能取其地址；（5）不能由用户直接调用；

int a ;      //在C中为声明，在C++为定义

在C++/C中，全局变量（extern 或 static）存放在程序的静态数据区中，在程序进入main之前创建，在main结束之后销毁，因此我们的代码没有机会初始化它们。

全局的声明和定义应放在源文件的开头位置。

C++的访问控制策略是为了防止意外事件而不是为了防止对编译器的故意欺骗。

class Base{

public:

       virtual Say() {std::cout<<”Base::Say() was invoked”<<std::endl;}

};

Class Derived:public Base{

private:

       virtual Say() {std::cout<<”Derived::Say() was invoked”<<std::endl;}

}

//测试

void test(void){

       Base *p = new Derived;

       p->Say();       //出乎意料的绑定到了一个private函数上！

类型转换并不是改变原来的类型和值，而是生成了新的临时变元，其类型为目标类型。

标准C允许非void 类型指针和void 类型指针互相转化，而标准C++只允许非void 指针转化为void 类型指针，反过来是需要强制转换。

强制转换中的内存截断和内存扩张：

double d = 1000.25;

int *pInt = (int*)&d;

int i = 100;

double *pDbl = (double*)&i;

不要用前导“_”定义自己的标志符。

基本数据类型的字面常量、枚举常量、sizeof()、常量表达式，不需要分配存储空间，编译时放到程序的符号表(不是ROM，不能取地址)中；而字符串常量、const常量（尤其是ADT/UDT的const对象）就要分配运行时存储空间。

布尔变量与零值比较：if(flag) 或if(!flag)

整型变量与零值比较：if(0==value ) 或 if(0!=value)

浮点变量与零值比较：if(abs(x)<=EPSILON) 或 if(abs(x)>=EPSILON)

指针变量与零值比较：if(NULL==p) 或 if(NULL!=p)

不要忘记switch的default ，即使不需要。

如果循环体中出现了continue语句，要防止它跳过循环变量修改语句，因此最好把循环变量的修改放在前面。

如果你的循环是确定的，用for；不确定，用while。

for中计数器一律用“前闭后开法”。

在多层嵌套的循环中，应尽可能把最长的循环放在最内层。

如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。

第六章 C++/C常量

事实上只存在基本数据类型的字面常量。

在C中，const定义的常量是不能修改的变量，因此会给它分配空间(外连接的)；但C++中，对于基本类型常量放到符号表中，对于ADT/UDT的const对象则需要分配内存。还有一些，如强制声明的extern的符号常量或取符号常量的地址，会分配存储空间。

const long lng = 10;           

long *pl = (long*)&lng;         //去取常量地址

*pl = 1000;                          //“迂回修改”

cout << *pl << endl;             //1000,修改拷贝

cout << lng << endl;             //10，原始常量并没有修改

对于构造类型的const 对象，它成了编译时不允许修改的变量，但可以绕过。

Class Integer

{

       Public:

              Long m_lng;

};

const Integer int_1;

int_1.m_lng = 0;

Integer *pInt = (Integer*)&int_1;  //去除常熟性

pInt->m_lng = 1000;

cout << pInt->m_lng << endl;      //1000,修改const对象

cout << int_1.m_lng << endl;              、//1000，“迂回修改” 成功!

理论上，只要能得到对象的地址，你就可以设法绕过编译器随意修改它，除非有操作系统的保护。

在C中，const符号常量默认是外连接的，也就是说不能在两个以上的源文件中定义一个同名的const符号常量，或这把一个const符号常量放在头文件中而在多个源文件爱您中包含该头文件。而C++中const默认是内连接的，每个编译单元编译时会分别为它们分配内存，在连接时进行常量折叠。

（1）       const常量有数据类型，而宏常量没有，因此没有类型检查。

（2）       有些调试工具可以对const常量进行调试。

因此C++中应尽量用const 而不用#define。

非静态const数据成员是属于每一个对象的成员，只在某个对象的生存期内常量，而对于整个类是可变的，除非是static const。因此不能在类声明中初始化非静态const数据成员，只能在构造函数的初始化列表中初始化。

如何建立在整个类中都恒定的类常量？

（1）用枚举常量；（2）static const。

class A{

       enume

       {

              SIZE1 = 100,SIZE2 = 200

};

int array1[SIZE1];

int array2[SIZE2];

};

第七章 函数设计基础

连接的本质就是把一个名字的实现绑定到对它的每一个引用上。

如果函数没有参数，那么使用void 而不要空着。因为标准C把空参数列表解释为可以接受任何类型和任意个数的参数，而C++解释为不接受任何实参。

一般，输出参数放在前面，输入参数放在后面。

不要忽略返回类型。C认为会返回int。

为了避免误解，应当将正常值和错误标志分开，即正常值用输出参数获得，而错误标志用return 语句返回。如将标准C中的int getchar()改为bool GetChar(char*)就好多了。

尽管语法允许，但请不要在内层程序块中覆盖外层程序块的名字，否则会损害程序的可理解性。

非静态全局函数和全局变量，名字空间的成员是外连接的。

在函数的入口处，建议用断言来检测参数的有效性。

Use const whenever you need.

第八章 函数和指针

int* a,b,c;              会理解为int *a,b,c，因此不要用这种声明方式。

向函数传递多维数组，不需要说明第一维大小而必须说明其它各维大小。

任何成员函数都是独立于类的对象而存在的，所以能够取到一个成员函数的地址。

为了与静态成员函数区别，取virtual 函数和普通成员函数的地址必须要使用&运算符，但取静态成员函数地址不必要。

构造类型虽然可以嵌套定义，但其嵌套递定义的类型对象不一定就存在包含关系，存在包含关系的对象类型也不一定是嵌套定义的。当一个类型A只会在另一个类型B中被使用时，就可以把A定义在B 的定义体内，这样可以减少暴露在外面的用户自定义类型的个数。

第九章 高级数据类型

默认的拷贝赋值函数就是对象的位拷贝语义，但不能直接比较大小。

位域

不要定义超过类型最大维数的位域成员。、

可以定义匿名的位域成员，其语义是占位符。

可以定义长度为0 的位域成员，其作用是迫使下一个成员从下一个完整的机器字开始分配空间。

不要让一个位域成员跨字节，这样会增加计算开销。

union

使用一个成员存入而用另一个成员取出是可以的，但可能不是你想要的。

在定义联合变量时可以指定初值，但是只能指定一个初始值，且该初始值必须与联合的第一个成员的类型匹配。你可以取联合的地址，也可以取其成员的地址，它们都是联合的地址。你可以在同类型联合之间赋值，但你不能比较两个联合变量的大小，不光是因为肯能的填补字节，而且这两个变量可能存储着不同类型的成员，此时它们代表这两个不同类型的变量。

C++对联合进行了扩充，除了数据成员还可以定义成员的访问说明符，可以定义成员函数，甚至可以定义构造函数和析构函数；但联合不能包含虚函数和静态数据成员，不能作为基类。C++还支持匿名联合。

匿名的枚举类型就相当于直接定义的const符号常量。

第十章 C++/C 编译预处理

（1）带参数的宏体和各个参数都应用括号括起来。

（2）不要在引用宏定义的参数列表用++和--。

（3）带参数的宏定义不是函数，因此没有函数调用的开销，但是每一处宏扩展会生成重复代码，会使代码体积增大。

给宏添加注释用/*…*/，不要用//，因为有些编译器会把宏后面的行注释理解为宏的以部分。

宏名用大写字母并在各个单词中间用“_”隔开。

如果要公布某个宏，那么宏定义应放在头文件中，否则放在源文件顶部。

不要使用宏来定义新类型名，应使用typedef。

# 构串操作符，##合并操作符。

第十一章 C++/C文件结构和程序版式

ADT/UDT版式：

先public 后private。

第十二章 C++/C应用程序命名规则

类名、函数名首字母应大写，变量名、参数名首字母应小写。

静态变量以s_开头，全局变量以g_开头，成员变量以m_开头。

第十三章 C++/C面向对象程序设计方法概述

编写拷贝赋值函数的原则：

(1)    一定要检查自赋值，地址相等时才认为是同一个对象；

(2)    返回本对象引用，用return *this。

如：

String& String::operator=(const String& other){

       //检查自赋值

       if(this != other){

              //释放原有的内存资源

              delete[] m_data;

              //分配新的内存资源，并复制内容

              int len = strlen(other.m_data);

              m_data = new char[len + 1];

strcpy(m_data,other.m_data);

m_size = len;

}

       //返回本对象的引用

       return *this;

}

如果不想编写，也不想让别人调用，可将拷贝构造函数和拷贝赋值函数声明为private。

如何实现派生类的基本函数：

(1)    派生类的构造函数应在其初始化列表里显式地调用基类的构造函数；

(2)    如果基类是多态类，那么必须把基类的析构函数定义为虚函数。

如：

#include <iostream>

class Base{

public:

       virtual ~Base() {std::cout<<”Base::~Base()”<<std::endl;}

};

class Derived{

public:

       virtual ~Derived() { delete p_test;std::cout<<”Derived::~Derived()”<<std::endl;}

private:

       char *p_test;

};

int main(void){

       Base *pB = new Derived;

       Delete pB;

       return(0);

}

&

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

第一章 快速入门

main函数的返回值必须是int型。

在写C++程序时，大部分出现空格的地方可用换行符答题，但字符串字面量中的空格例外。另一个例外是空格不允许出现在预处理器指示中。

任何允许有制表符、空格或换行的地方都允许放注释对。

第二章 变量和基本类型

基本类型：bool, char, wchar_t, short, int, logn, float, double, long double.

整型字面量默认类型为int  或 long。可在后加L、l或U、u以及UL指定其类型。

浮点字面量默认为double，可在后加上F或L。

可在字符字面量后加L使之成为wchar_t。

连接字符串字面量和宽字符串字面量，其行为是未定义的。

C++ 保留了一些词用作操作符替代用于支持某些不支持C++ 操作符的字符集，这些词不能用作标志符，如：and or nor xor……

C++还保留了一组标志符用于标准库，标志符不能包含两个连续的下划线，也不能以下划线开头后跟一个大写字符。

C++支持两种初始化：复制初始化和直接初始化：

int ival(1024);        //direct-initialization

int ival = 1024;      //copy-initialization

非const 引用只能绑定到同类型的对象；const 引用则可绑定到相关但不同类型的对象或绑定到右值。

第三章 标准库类型

在头文件中，请不要用using 引入命名空间，要用完全限定的标准库名称。

当string 对象和字符串字面值混合连接时，+ 操作符左右必须至少有一个string 对象。

现代C++程序员倾向于使用迭代器而不是下标。所有的标准库容器都定义了相应的迭代器，只有少数几种才定义了下标操作。

第四章 数组和指针

非const 变量和运行时才知道其值的 const 变量不能用做数组的维数。

允许0字面量或编译时获得0值的const变量赋给指针，但不允许将一个值为0的 int 型变量赋给指针。

void 指针只支持几种有限的操作：与另一个指针比较；向函数传递void*指针或返回void* 指针；给另一个void*指针赋值。不允许使用void* 指针操纵它所指向的对象。

指针和引用的差别：引用必须在定义时初始化；引用总是指向同一个对象。

两个指针的减法操作的结果是ptrdiff_t 类型的。

typedef string *pstring;

const pstring cstr;

cstr是一个指向string 对象的 const指针！

动态分配数组时，如果数组元素具有类类型，将使用该类的默认构造函数实现初始化；如果数组元素是基本类型，则无初始化，但可在后加()强制初始化。

char *cp = new char[0]; //ok,but can't be dereferenced

但是此指针可以进行比较运算，+0，-0。

第五章 表达式

不要在一个表达式中对同一个变量进行多次++ 或 – 操作。

第六章 语句

只能在最后一个case 或 default 中定义变量，这是为了避免出现代码跳过变量定义和初始化的情况。

goto 语句不能向后跳过变量定义语句。

标准异常类型只定义了一个what 函数，返回一个C字符串。

第七章 函数

函数不能返回另一个函数或数组，但可以返回指向它们的指针。

将引用或指针形参定义为const 来重载函数是合法的。

第八章 标准IO库

IO 对象不可复制或赋值。

第九章 顺序容器

将一个容器复制给另一个容器时，类型必须精确匹配。

vector ivec;

vector ivec2(ivec);        //ok

vectordvec(ivec);    //error

list ilist(ivec);               //error

stack 可用三个做容器；

queue需要基本容器支持push_front 操作，只能用deque 和 list ；

priority_queue 要求基本容器有随机访问功能，只能用vector 和 deque。

第十章 关联容器

关联容器不能通过大小来定义，因为这样的话就无法知道键所对应的值是什么。