国产2021久久精品,国产精品VIDEOSSEX久久发布,国产福利电影一区二区三区久久久久成人精品综合

henry08 — Tue, 09 Dec 2008 05:43:00 GMT

1. 数据�c�d��和变�?/h2>
C++ 中的变量�c�d��与Java很相伹{��像Java一��P��C++ �?tt>int �?`double` �c�d��。但是这些数字类型的取��D��围是依赖于机器的。比如在16位系�l�上�Q�例如运行DOS 或Windows 3.x的PC��Z��Q?tt>int 是双字节(2-byte)的，取��D��围比Java�?-byte�?tt>int 要小很多。在�q�些机器上，如果 int 不够用的话，你需要��用长整型long�?/p>
C++ �?`short` �?`unsigned` �c�d��来更有效的存储数字。（我认为所谓有效是指更高的�I�间利用率。）最好是��量避免使用�q�些�c�d��除非是空间利用的有效性对你的�pȝ��真的非常重要�?/p>
在C++中布��型�?`bool` 表示�Q�而不像在Java中用boolean�?/p>
C++ 中字�W�串�c�d��?`string` 表示。它与Java中的 `String` �c�d��非常�怼��Q�但是，�q�是要逐一以下几点不同之处�Q?/p>
1. C++ 字符串存储ASCII 码字�W�，而不是标准码Unicode 字符

2. C++ 字符串是可以被修改的�Q�而Java字符串的内容是不可修改的(immutable)�?/p>
3. 取子字符串的操作�?C++ 中叫�?`substr`�Q�这个命�?tt>s.substr(i, n) 从字�W�串s中取得从位置 i 开始长度�ؓn的子字符丌Ӏ?/p>
4. 在C++中，你只能够��字�W�串与其它字�W�串对象�怸��?concatenate)�Q�而不能够与�Q意的对象�怸�联�?/p>
5. C++中可以直接��用关�p�L��作符 `==�?!=�?<�?<=�?>�?>=` 来进行字�W�串比较�Q�其中后面四个操作符是按字母��序�q�行比较的�?�q�比Java中��用函数equals和compareTo来比较要方便很多�?/p>

2. 变量和常�?/h2>
在C++中，本地变量的定义看��h��与Java中相同，例如�Q?/p>
`int n = 5;`

实际上这正是C++和Java的一个重要不同之处。C++�~�译器不�Ҏ��地变量进行初始化��验，所以在C++中很�Ҏ��忘记初始化一个变量，�q�种情况下，变量的��D��变量所占内存区域中刚好当前存在随机倹{��这昄��是很�Ҏ��产生�E�序出错的地斏V�?/p>
与Java一��P�� C++中类可以有数据域和静态变量。不同的是，C++中变量可以在函数甚至是类的外面定义，�q�些所谓的全局变量可以在程序的��M��函数中被讉K��Q�因而不易被很好的管理。所C++中应该尽量避免��用全局变量�?/p>
在C++中，帔R��可以在�Q何地方被定义�Q�记得在Java中，帔R��必须是类的静态数据static data)�?C++ 使用关键�?`const` 来定义常量，而Java中是 `final`。例如：

`const int DAYS_PER_YEAR = 365;`

3. �c?/h2>
C++ 中对�cȝ��定义与Java有些不同�Q�这里是一个例子：一个C++ 版本�?`Point` �c?

`class Point /* C++ */`

`{`

`public:`

`Point();`

`Point(double xval, double yval);`

`void move(double dx, double dy);`

`double getX() const;`

`double getY() const;`

`private:`

`double x;`

`double y;`

`};`

�q�里几点重要的不同是�Q?/p>
1. C++的类定义中分为公共和�U�有部分�Q�分别以关键�?`public` �?`private`开始。而在Java中，每一个元素都必须标明 `public` �?`private`�?/p>
2. C++中类的定义只包含函数的声明，真正的实现另外单独列出�?/p>
3. 讉K��函数(accessor methods)标有关键�?`const` �Q�表明这个函��C��会改变本对象的元素倹{�?/p>
4. �c�d��义的�l�尾处有分号

�c�M��函数的实现跟在类的定义之后。因为函数是在类外面定义的，所以每一个函数的名字前面要加�c�d��U�C��为前�~��Q��ƈ使用操作�W�双冒号::来分割类的名�U�和函数的名�U�。不改变隐含参数��|��卛_��前对象的��|��的访问函数用 `const`标明。如下所�C�是上面�c�d��义中的函数的实现�Q?/p>
`Point::Point() { x = 0; y = 0; }`

`void Point::move(double dx, double dy)`

`{`

`x = x + dx;`

`y = y + dy;`

`}`

`double Point::getX() const`

`{`

`return x;`

`}`

4. 对象

Java �?C++ 最主要的不同在于对象变量的使用。在 C++中，对象变量存储的是真正的对象的��|��而不是对象引�?reference)。注意在C++中构造一个对象的时候是不��用关键字new的，只需要在变量的名字后面直接赋予构造函数的参数��可以了�Q�例如：

Point p(1, 2); /* 构造对�?p */

如果不跟参数赋��|��则��用默认构造函敎ͼ�例如�Q?/p>

Time now; /* 默认使用构造函�?Time::Time() */

�q�一点与Java很不同。在Java中，�q�个命��o仅仅生成一个没有初始化的reference�Q�而在C++中，它生成一个实际的对象�?/p>

当一个对象被赋给另一个对象变量的时候，实际的值将被拷贝。而在Java中，拯��一个对象变量只不过是徏立了另外一个指向对象的reference。拷贝一个C++的对象就像在Java中调用clone�q�个函数一��P��而修�Ҏ��贝的��g��会改变原对象的倹{��例如：

Point q = p; /* 拯��p到q */

q.move(1, 1); /* �U�d��q而p不动�Q�即q的值变了，而p的不�?/

多数情况下，C++中这�U�对象直接对值操作的�Ҏ��用�v来很方便�Q�但是也有些时候不��如人意�Q?/p>

1. 当需要一个函��C��修改一个对象的��|��必须��C��要��用按引用调用call by reference (参见下面函数部分)

2. 两个对象变量不能指向同一个对象实体。如果你要在C++中实现这�U�效果，必须使用指针pointer�Q�参见下面指针部分）

3. 一个对象变量只能存储一�U�特定的�c�d��的��|��如果你想要��用一个变量来存储不同子类的对象的��|��多态ploymorphism)�Q�则需要��用指针�?/p>

4. 如果你想在C++中��用一个变量来或者指向null或者指向一个实际的对象�Q�则需要��用指�?/p>

5. 函数

在Java中，每一个函数必��L��者是对象函数(instance method)�Q�或者是静态函�?static function)或称�c�d��数。C++同样支持对象函数和静态函敎ͼ��c�d��敎ͼ��Q�但同时C++也允许定义不属于��M��cȝ��函数�Q�这些函数叫做全局函数�Q�global functions�Q?/em>�?/p>

特别的是�Q�每一个C++ �E�序都从一个叫�?main的全局函数开始执行：

int main()

{ . . .

}

�q�有另外一个格式的main函数可以用来捕捉命��o行参敎ͼ��c�M��于Java的main函数�Q�但是它要求关于C格式的数�l�和字符串的知识�Q�这里就不介�l�了�?/p>
按照习惯�Q�通常如果�E�序执行成功�Q?main 函数�q�回0�Q�否则返回非零整数�?/p>
同Java一��P��函数参数是通过��g��递的(passed by value)。在Java中，函数无论如何都是可以修改对象的值的。然而在C++中，因�ؓ对象直接存储的是实际的��|��而不是指向值的reference�Q�也��是说传入函数的是一个实际值的拯��Q�因此也��无法修改原来对象的倹{�?/p>
所以，C++ 有两�U�参��C��递机�Ӟ��同Java一��L��按��D��?call by value) �Q�以及按地址调用(call by reference)。当一个参数是按reference传递时�Q�函数可以修改其原始倹{��Call by reference 的参数前面有一个地址�?& 跟在参数�c�d��的后面，例如�Q?/p>
void raiseSalary(Employee& e, double by)

{ . . .

}

下面是一个典型的利用call by reference的函敎ͼ�在Java中是无法实现�q�样的功能的�?/p>
void swap(int& a, int& b)

{ int temp = a;

a = b;

b = temp;

}

如果使用 swap(x, y)来调用这个函敎ͼ�则reference参数 a �?b 指向原实际参�?tt>x �?y的位�|�，而不是它们的值的拯��Q�因此这个函数可以实现实际交换这两个参数的倹{�?/p>
�?C++中，每当需要实��C��改原参数的值时你就可以使用按地址调用 call by reference

6. 向量Vector

C++ 的向量结构结合了Java中数�l�和向量两者的优点。一个C++ 的向量可以方便的被访问，其容量又可以动态的增长。如�?T 是�Q意类型，�?vector 是一个元素�ؓ T �c�d��的动态数�l�。下面的语句

vector a;

产生一个初始�ؓ�I�的向量。而语�?/p>
vector a(100);

生成一个初始有100个元素的向量。你可以使用push_back 函数来添加元素：

a.push_back(n);

调用 a.pop_back() �?tt>a中取出最后一个元素（操作后这个元素被从a中删�?�Q?使用函数size 可以得到当前a中的元素个数�?/p>
你还可以通过我们熟悉�?[] 操作�W�来讉K��向量中元素，例如�Q?/p>
for (i = 0; i < a.size(); i++) {

sum = sum + a[i];

}

同Java中一��P��数组索引必须�?0 �?a.size() - 1之间的倹{��但是与Java不同的是�Q�C++中没有runtime的烦引号合法性检验。试图访问非法的索引位置可能造成非常严重的出错�?/p>
��像所有其�?C++ 对象一��P��向量也是倹{��如果你��一个向量赋值给另外一个向量变量，所有的元素都会被拷贝过厅R�?/p>
vector b = a; /* 所有的元素都被拯��?*/

�Ҏ��Java中的情况�Q�在Java中，一个数�l�变量是一个指向数�l�的reference。拷贝这个变量仅仅��生另外一个指向同一数组的reference�Q�而不会拷贝每一个元素的倹{�?/p>
正因如此�Q�如果一个C++函数要实��C��改向量的��|��必须使用reference参数�Q?/p>
void sort(vector& a)

{ . . .

}

7. 输入和输�?/h2>
在C++中，标准的输入输出流用对�?cin �?cout 表示。我们��?<< 操作�W�写输出�Q�例如：

cout << “Hello, World!”;

也可以连着输出多项内容�Q�例如：

cout << “The answer is ” << x << “\n”;

我们使用 >> 操作�W�来��d��一个数字或单词�Q�例如：

double x;

cout << “Please enter x: “;

cin >> x;

string fname;

cout << “Please enter your first name: “;

cin >> fname;

函数getline 可以��d��整行的输入，例如�Q?/p>
string inputLine;

getline(cin, inputLine);

如果到达输入的结��，或者一个数字无法被正确的读入，�q�个��对象会被设�|��ؓ failed 状态，我们可以使用函数 fail 来检验这个状态，例如�Q?/p>
int n;

cin >> n;

if (cin.fail()) cout << “Bad input”;

一旦一个流的状态被设�ؓfailed�Q�我们是很难重置它的状态的�Q�所以如果你的程序需要处理错误输入的情况�Q�应该��用函�?getline 然后人工处理得到的输入数据�?/p>

8. 指针pointer

我们已经知道在C++中，对象变量直接存储的是对象的倹{��这是与Java不同的，在Java中对象变量存储的是一个地址�Q�该地址指向对象值实际存储的地方。有时在C++中也需要实现这��L��布置�Q�这��q��C��指针pointer。在 C++中，一个指向对象的变量叫做指针。如果T是一�U�数据类型，�?T* 是指向这�U�数据类型的指针�?/p>
��像 Java中一��P��一个指针变量可以被初始化�ؓ�I��?NULL�Q�另外一个指针变量的��|��或者一个调用new生成的新对象�Q?/p>
Employee* p = NULL;

Employee* q = new Employee(”Hacker, Harry”, 35000);

Employee* r = q;

实际上在C++中还有第四种可能�Q�那��是指针可以被初始化为另外一个对象的地址�Q�这需要��用地址操作�W?& �Q?/p>
Employee boss(”Morris, Melinda”, 83000);

Employee* s = &boss;

�q�实际上�q�不是什么好��L��。保险的做法�q�是应该直接让指针指向��?new生成的新对象�?/p>
到目前�ؓ止，C++ 指针看�v来非常像 Java 的对象变量。然而，�q�里有一个很重要的语法的不同。我们必��M��用星��h��作符 * 来访问指针指向的对象。如�?p 是一个指�?tt>Employee对象的指针，�?*p 才代表了�q�个对象�Q?/p>
Employee* p = . . .;

Employee boss = *p;

当我们需要执行对象的函数或访问对象的一个数据域�Ӟ��也需要��?*p �Q?/p>
(*p).setSalary(91000);

*p外面的括��h��必需的，因�ؓ . 操作�W�比 * 操作�W�有更高的优先��。C的设计者觉得这�U�写法很隄��Q�所以他们提供了另外一�U�替代的写法�Q��?-> 操作�W�来实现 * �?. 操作�W�的�l�合功能。表辑ּ�

p->setSalary(91000);

可以调用对象*p的函�?setSalary 。你可以��单的��C�� . 操作�W�是在对象上使用的，-> 操作�W�是在指针上使用的�?/p>
如果你不初始化一个指针，或者如果一个指针�ؓ�I��?NULL 或指向的对象不再存在�Q�则在它上面使用 * �?-> 操作�W�就会出错�?不幸的是 C++ runtime �pȝ��q�不��查这个出错。如果你范了�q�个错误�Q�你的程序可能会行�ؓ古怪或��L��?/p>
而在Java中，�q�些错误是不会发生的。所有的reference都必��d��始化�Q�所有的对象只要仍有reference指向它就不会被从内存中清除，因此你也不会有一个指向已被删除的对象的reference。Java的runtime �pȝ��会检查reference是否为空�Q��ƈ在遇到空指针时抛��Z��个null pointer的例�?exception)�?/p>

C++ �?Java�q�有一个显著的不同�Q�就�?Java �?em>垃圾回收功能�Q�能够自动回收被废弃的对象。而在C++中，需要程序员自己��理内存分配回收�?/p>

C++中当对象变量��出范围时可以自动被回收。但是��用new生成的对象必��ȝ��delete操作�W�手动删除，例如�Q?/p>

Employee* p = new Employee(”Hacker, Harry”, 38000);

. . .

delete p; /* 不在需要这个对�?*/

如果你忘记删除一个对象，那么你的�E�序有可能最�l�用光所有内存。这��是我们常说的内存泄�?(memory leak)。更重要的是�Q�如果你如果删除了一个对象，然后又��l��用它�Q�你可能覆盖不属于你的数据。如果你刚��y覆盖了用于处理内存回收的数据域，那么内存分配机制��可能运转失常而造成更严重的错误�Q�而且很难诊断和修复。因此，在C++中最好尽量少用指�?/p>

9. �l�承

C++和Java中��承的基本语法是很�怼�的。在C++中，使用 : public 代替Java中的extends 来表�C��承关�p?�?(C++ 也支持私有��承的概念�Q�但是不太有用�?

默认情况下，C++中的函数不是动态绑定的。如果你需要某个函数实现动态绑定，需要��?tt>virtual声明它�ؓ虚函敎ͼ�例如�Q?/p>

class Manager : public Employee

{

public:

Manager(string name, double salary, string dept);

virtual void print() const;

private:

string department;

};

同Java一��P��构造函��C��调用父类的构造函数有�Ҏ��的语法�?Java使用关键�?super。C++中必��d��子类的构造函��C��外调用父�cȝ��构造函数。下面是一个例子：

Manager::Manager(string name, double salary, string dept)

: Employee(name, salary) /* 调用父类的构造函�?*/

{ department = dept;

}

Java 中在子类函数中调用父�cȝ��函数时也使用关键�?super 。而在C++中是使用父类的名�U�加上操作符 ::表示�Q�例如：

void Manager::print() const

{ Employee::print(); /* 调用父类的函�?*/

cout << department << “\n”;

}

一�?C++ 对象变量只能存储特定�c�d��的对象倹{��要惛_��C++中实现多�?polymorphism)�Q�必��M��用指针。一�?T* 指针可以指向�c�d��?T �?T 的�Q意子�cȝ��对象�Q�例如：

Employee* e = new Manager(”Morris, Melinda”, 83000, “Finance”);

你可以将父类和不同子�cȝ��对象混合攉��C��个元素均为指针的向量中，然后调用动态绑定的函数�Q�如下所�C�：

vector staff;

. . .

for (i = 0; i < staff.size(); i++)

staff[i]->print();

henry08 2008-12-09 13:43 发表评论

正确的方法是定义operator++以reference为参数类�? C++中Reference与指针（Pointer�Q�的使用�Ҏ��

henry08 — Tue, 09 Dec 2008 05:16:00 GMT

day &operator++(day &d)
{
d = (day)(d + 1);
return d;
}

使用�q�个函数�Q?表达�?++x 才有正确的显�C�Z��及正��的操作�?br>Passing by reference不仅仅是写operator++较好的方法，而是唯一的方法�?br>

C++在这里�ƈ没有�l�我们选择的余地�?br> 像下面的声明:
day *operator++(day *d);
是不�?通过�~�译的�?br>每个重蝲的操作符函数必须或者是一个类的成员，或者��用类型T�?T & �?T const & 为参数类型，
�q�里T是一个类(class)或列�?enumeration)�c�d��?

也就是说�Q�每一个重载操作符必须以类或列丄��型�ؓ参数�c�d��?br>
指针�Q�即使是指向一个类或列丄��型对象的指针�Q�也不可以用�?br>
C++ 不允许在重蝲操作�W�时重新定义内置操作�W�的含义�Q�包括指针类型�?br>因此�Q�我们不可以定义�Q?br>int operator++(int i); // 错误
因�ؓ它试囑֯�int重新定义操作�W?++ 的含义�?我们也不可以定义�Q?br>int *operator++(int *i); // 错误
因�ؓ它试囑֯� int * 重新定义操作�W?++ 的含�?br>

References vs. const pointers

C++ 中不允许定义”const reference”�Q?br> 因�ؓ一个reference天生��是const。也��是��_��一旦将一个reference�l�定��C��个对象，��无法再��它重新�l�定到另一个不同的对象�?br>在声明一个reference之后没有写法可以��它重新�l�定到另外一个对象�?br>例如�Q?br>int &ri = i;
��?ri �l�定�?i 。然后下面的赋�?
ri = j;
�q�不是把 ri �l�定�?j �Q�而是��?j 中的��D��l?ri 指向的对象，也就是赋�l?i �?br>

��而言之，
一个pointer在它的有生之�q�可以指向许多不同的对象�Q?br>而一个reference只能够指向一个对象�?br>有些��才是 reference�?pointer最大的不同�?br>我�ƈ不赞成。也许这是reference与pointer的一点不同，但�ƈ不是reference和const pointer的不同�?br>在强调一遍，一旦一个reference与一个对象绑定，��׃��能再��它�Ҏ��向另外的东西�?br>既然不能再绑定reference之后�?改变�Q?一个reference��必��d��一出生��p��l�定�?br>否则�q�个reference��永�q�不能被�l�定��C�Q何东西，也就毫无用处了�?/p>

上一�D늚�讨论也同样完全适用于常量指针（const pointer�Q��?br>�Q�注意，我这里说的是帔R��指针�Q�const pointer�Q�，而不是指向常量的指针 “pointers to const”�?
例如�Q?br>一个reference声明必须同时带有一个初始化赋��|��如下所�C�：

void f()
{
int &r = i;
…
}

省略�q�个初始化赋值将产生一个编译错误：

void f()
{
int &r; //错误
…
}

一个常量指针的声明也同样必��d��有一个初始化赋��|��如下所�C�：

void f()
{
int *const p = &i;
…
}

省略�q�个初始化赋值同样会出错�Q?/p>

void f(){
int *const p; // 错误
…
}

在我看来
不能够对reference二次�l�定作�ؓreference与pointer的不同�?br>�q�不比常量指针和非常量指针的不同更�ؓ显著�?br>

Null references

除了昄��的不同，帔R��指针与reference�q�有一炚w��怸�同，那就是，一个有效的reference必须指向一个对象；而一个指针不需要。一个指针，即��是一个常量指针，都可以有�I�倹{�?一个空指针不指向�Q何东�ѝ�?/p>

�q�点不同��暗�C�当你想要确信一个参数必��L��向一个对象的时候，应该使用reference作�ؓ参数�c�d��?例如�Q�交换函�?swap function)�Q�它接受两个int参数�Q��ƈ��两个参数的数值对调，如下所�C�：

int i, j;
swap(i, j);

��原本在 i 中的值放�?j 中， �q�将原本�?j 中的值放�?i 中。我们可以这样写�q�个函数�Q?/p>

void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}

�q�种定义下，函数要像�q�样被调�? swap(&i, &j);

�q�个接口暗示其中一个或两个参数都有可能为空(null)。而这个暗�C�是误导的。例如，调用
swap(&i, NULL);
的后果很可能是不愉快的�?/p>

而像下面�q�样定义reference为参敎ͼ�

void swap(int &v1, int &v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}

清晰的表明了调用swap应该提供两个对象�Q�它们的值将被交换�?�q�且�q�样定义的另一个好处是�Q�在调用�q�个函数的时候，不需要��用那�?amp;�W�号�Q�看��h��更顺��|��
swap(i, j);

Null references

除了昄��的不同，
帔R��指针与reference�q�有一炚w��怸�同，
那就是，一个有效的reference必须指向一个对象；

�?span style="COLOR: red">一个指针不需�?/span>�?br>一个指针，即��是一个常量指针，都可以有�I�倹{�?一个空指针不指向�Q何东�ѝ�?br>

�q�点不同��暗�C�当你想要确信一个参数必��L��向一个对象的时候，应该使用reference作�ؓ参数�c�d��?/span>
例如�Q?br>交换函数(swap function)�Q�它接受两个int参数�Q��ƈ��两个参数的数值对调，如下所�C�：

int i, j;
swap(i, j);

��原本在 i 中的值放�?j 中， �q�将原本�?j 中的值放�?i 中。我们可以这样写�q�个函数�Q?/p>

void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}

�q�种定义下，函数要像�q�样被调�? swap(&i, &j);

�q�个接口暗示其中一个或两个参数都有可能为空(null)。而这个暗�C�是误导的。例如，调用
swap(&i, NULL);
的后果很可能是不愉快的�?/p>

而像下面�q�样定义reference为参敎ͼ�

void swap(int &v1, int &v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}

更安�?

有些��为既然reference不能够�ؓ�I�，那么它应该比指针更安全�?br> 我认为reference可能要安全一点，但不会安全很多�?br>虽然一个有效的reference不能为空�Q�但是无效的可以呀�?br>实际上，在很多情况下�E�序有可能��生无效的reference�Q�而不只是�I�的reference�?/span>

例如�Q?/span>
你可以定义一个reference�Q��它绑定到一个指针指向的对象�Q�如下所�C�：

int *p;
…
int &r = *p;

如果指针*p在reference定义时刚好�ؓ�I�，则这个reference为空�?br> 从技术上来说�Q�这个错误�ƈ不在于将reference�l�定��C��个空��|��而是在于对一个空指针��d��考�?br> 对一个空指针��d��考��生了一个不��定的操作，也就意味着很多事都可能发生�Q�而且大部分都不是什么好事。很有可能当�E�序��reference r �l�定�?p (p所指向的对�?的时候，p实际上没有被��d��考，甚至�E�序只是��p的值拷贝给实现r的指针�?br>而程序将会��l�执行下�ȝ��到错误在后面的运行中更�ؓ明显的表现出来，产生不可预知的危実�?/p>

下面的函�?br>展示�?br>另外一�U��生无效reference的方法：

int &f()
{
int i;
…
return i;
}

�q�个函数�q�回一个指向本地变�?i 的reference�?br>然而当函数�q�回�Ӟ��本地变量 i 的存储空间也��消�׃��。因此这个函数实际返回了一个指向被回收了的�I�间的reference。这个操作与�q�回一个指向本地变量的指针的后果相同�?br>有些�~�译器可以在�~�译时发现这个错误，但也很有可能不会发现�?br>

我喜�Ƣreference�Q�也有很好的理由使用它们代替pointer�?br>
但如果你期望使用reference来��你的�E�序健壮性显著增强，那么你多半会失望�?br>

参考资料：

Saks, Dan. “Introduction to References,” Embedded Systems Programming, January 2001, p. 81.
Saks, Dan. “References and const“, Embedded Systems Programming February 2001, p. 73.

henry08 2008-12-09 13:16 发表评论

VC6.0中重载操作符函数无法讉K��cȝ��U�有成员

henry08 — Mon, 08 Dec 2008 15:50:00 GMT

�?C++ 中，操作�W?�q�算�W�）可以被重载以改写其实际操作�?br>同时我们可以定义一个函��Cؓ�cȝ��朋友函数(friend function)以便使得�q�个函数能够讉K��cȝ��U�有成员�Q?br>�q�个定义通常在头文�g中完成�?/p>

在Visual C++中定义一般的函数为朋友函数通常是没有问题的�?br>然而对某些重蝲操作�W�的函数�Q?br>即��我们��它们定义�ؓ�cȝ��朋友函数�Q�VC的编译器仍然会显�C�出错信息，
认�ؓ�q�些朋友函数无权讉K��cȝ��U�有成员�?br>我认��应该是VC6.0的bug�?br>

以下代码��是个例�?

// 头文�?“Sample.h”
            #include
            using namespace std;
            class Sample {
            public:
            Sample();
            friend ostream &operator<<(ostream &out, const Sample s);
            friend istream &operator>>(istream &in, Sample & s);
            private:
            int x;
            };

// 实现文�g “Sample.cpp”
            #include “Sample.h”
            Sample::Sample() {
            x=0;
            }
            istream &operator>>(istream &in, Sample & s) {
            cout<<”Please enter a value”<> s.x ;
            return in;
            }
            ostream &operator<<(ostream &out, const Sample s) {
            cout << s.x << endl;
            return out;
            }

以上代码在gnuc++中编译运行毫无问题。但是在VC++6.0中编译的时候就会出��C��下的�~�译错误�Q?/p>

Compiling…
Sample.cpp
c:\temp\sample.cpp(8) : error C2248: ‘x’ : cannot access private member declared in class ‘Sample’
c:\temp\sample.h(19) : see declaration of ‘x’
c:\temp\sample.cpp(13) : error C2248: ‘x’ : cannot access private member declared in class ‘Sample’
c:\temp\sample.h(19) : see declaration of ‘x’
Error executing cl.exe.Sample.obj - 2 error(s), 0 warning(s)

在VC++ 6.0中解册��个问题有以下几种�Ҏ��Q?/p>

在头文�g中实��C��为朋友函数的操作�W�函数的重蝲�Q�也��是说在实现文�g”Sample.cpp”中将函数重蝲的实现去掉，而将头文件修改如下：

// 修改后的头文�?1 “Sample.h”
                #include
                using namespace std;
                class Sample {
                public:
                Sample();
                friend ostream &operator<<(ostream &out, const Sample s);
                friend ostream &operator<<(ostream &out, const Sample s) {
                cout << s.x << endl;
                return out;
                }
                friend istream &operator>>(istream &in, Sample & s);
                friend istream &operator>>(istream &in, Sample & s) {
                cout<<”Please enter a value”<> s.x ;
                return in;
                }
                private:
                int x;
                };

在头文�g中类定义之前��类和朋友操作符函数的原型特别声明一下，也就是将头文件修改如�?实现文�g”Sample.cpp”不用作�Q何修�?�Q?br>

// 修改后的头文�?2 “Sample.h”
                #include
                using namespace std;
                // 以下3行代码�ؓ新加�?
                class Sample;
                ostream &operator<<(ostream &out, const Sample s);
                istream &operator>>(istream &in, Sample & s);
                class Sample {
                public:
                Sample();
                friend ostream &operator<<(ostream &out, const Sample s);
                friend istream &operator>>(istream &in, Sample & s);
                private:
                int x;
                };

�W�三�U�方法是对I/O名空间的使用实行明确声明�Q�也��是说在头文�?#8221;Sample.h”中直接写�Q?br>#include
using std::ostream;
using std::istream
….
取代 “using namespace std;”
注意�Q�在�q�个例子里我们在实现文�g “Sample.cpp”中包�?“using namespace std;”�q�句话，否则在实��C��׃��能��?“cout” , “cin”, “<< “, “>>” �?endl �q�些关键字和�W�号。修改后的完整代码如下：

// Sample.h
                #include
                using std::istream;
                using std::ostream;
                class Sample {
                public:
                Sample();
                friend ostream &operator<<(ostream &out, const Sample s);
                /*friend ostream &operator<<(ostream &out, const Sample s) {
                cout << s.x << endl;
                return out;
                }*/
                friend istream &operator>>(istream &in, Sample & s);
                /*friend istream &operator>>(istream &in, Sample & s) {
                cout<<”Please enter a value”<> s.x ;
                return in;
                }*/
                private:
                int x;
                };

// “Sample.cpp”
                #include “Sample.h”
                using namespace std;
                Sample::Sample() {
                x=5;
                }
                istream &operator>>(istream &in, Sample & s) {
                cout<<”Please enter a value”<> s.x ;
                return in;
                }
                ostream &operator<<(ostream &out, const Sample s) {
                cout << s.x << endl;
                return out;
                }

henry08 2008-12-08 23:50 发表评论

�c�d��转换高�� (Advacned Class Type-casting)

henry08 — Mon, 08 Dec 2008 04:58:00 GMT

reinterpret_cast

reinterpret_cast 可以��一个指针�{换�ؓ��L��其它�c�d��的指�?/span>�?br>它也可以用来��一个指针�{换�ؓ一个整型，或反之亦然�?/p>

�q�个操作�W�可以在互不相关的类之间�q�行指针转换�Q?br>操作的结果是��单的��一个指针的二进制数�?binary copy)复制到另一个指针�?br>�Ҏ��针指向的内容不做��M��查或转换�?br>

例如�Q?/p>

class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast(a);

reinterpret_cast �Ҏ��有指针的处理与传�l�的�c�d��转换�W�所作的一模一栗��?br>
_________________________________________________________________

static_cast

static_cast 可以执行所有能够隐含执行的�c�d��转换�Q�以及它们的反向操作�Q�即使这�U�方向操作是不允讔R��含执行的�Q��?/p>

用于�cȝ��指针�Q�也��是��_��它允许将一个引申类的指针�{换�ؓ其基�cȝ��型（�q�是可以被隐含执行的有效转换�Q�，同时也允许进行相反的转换�Q�将一个基�c��{换�ؓ一个引申类�c�d��?/p>

在后面一�U�情况中�Q?span style="COLOR: red">不会��查被转换的基�c�L��否真正完全是目标�c�d��?/span>。例如下面的代码是合法的�Q?/p>

class Base {};
class Derived: public Base {};
Base * a = new Base;
Derived * b = static_cast(a);

static_cast除了能够对类指针�q�行操作�Q�还可以被用来进行类中明��定义的转换�Q�以及对基本�c�d��的标准�{换：

double d=3.14159265; int i = static_cast(d);

译者注�Q�如果你对这部分看不太懂�Q�请�l�合下面的dynamic_cast一��L��Q�也�怼�帮助理解�?/p>

dynamic_cast

dynamic_cast 完全被用来进行指针的操作。它可以用来�q�行��M��可以隐含�q�行的�{换操作以及它们被用于多态类情况下的方向操作�?br>
然而与static_cast不同的是�Q?br> dynamic_cast 会检查后一�U�情�늚�操作是否合法�Q?br>也就是说它会��查类型�{换操作是否会�q�回一个被要求�c�d��的有效的完整的对象�?/span>

�q�种��查是在程序运行过�E�中�q�行的。如果被转换的指针所指向的对象不是一个被要求�c�d��的有效完整的对象�Q�返回值将会是一个空指针NULL �?/p>

   class Base { virtual dummy(){}; };
   class Derived : public Base { };
   

   Base* b1 = new Derived;
   Base* b2 = new Base;
   Derived* d1 = dynamic_cast(b1);   // succeeds
Derived* d2 = dynamic_cast(b2);   // fails: returns NULL

如果�c�d��转换被用在引�?reference)�c�d��上，而这个�{换不可能�q�行的话�Q�一个bad_cast �c�d��的例�?exception)��会被抛出：

  class Base { virtual dummy(){}; };
  class Derived : public Base { };
  
  Base* b1 = new Derived;
  Base* b2 = new Base;
  Derived d1 = dynamic_cast(b1);   // succeeds
Derived d2 = dynamic_cast(b2);   // fails: exception thrown

const_cast

�q�种�c�d��转换对常量const �q�行讄��或取消操作：

class C {};
const C * a = new C;
C * b = const_cast (a);

其他3�U�cast 操作�W�都不可以修改一个对象的帔R��属�?constness)�?/p>

typeid

ANSI-C++ �q�定义了一个新的操作符叫做 typeid �Q?br>它检查一个表辑ּ�的类型：

typeid (expression)

�q�个操作�W�返回一个类型�ؓtype_info的常量对象指针，�q�种�c�d��定义在标准头函数中。这�U�返回值可以用操作�W?== �?!= 来互相进行比较，
也可以用来通过name()函数获得一个描�q�数据类型或�c�d��U�的字符�Ԍ��

例如�Q?/typeinfo>

    // typeid, typeinfo
            #include 
            #include 
            class CDummy { };
            int main () {
            CDummy* a,b;
            if (typeid(a) != typeid(b)) {
            cout << "a and b are of different types:\n";
            cout << "a is: " << typeid(a).name() << '\n';
            cout << "b is: " << typeid(b).name() << '\n';
            }
            return 0;
            }

a and b are of different types:
a is: class CDummy *
b is: class CDummy

henry08 2008-12-08 12:58 发表评论

名空�?(Namespaces)

henry08 — Mon, 08 Dec 2008 04:33:00 GMT

标准名空�?Namespace std)

我们能够扑ֈ�的关于名�I�间的最好的例子��是标准C++ 函数库本�w��?br>
如ANSI C++ 标准定义�Q?br>标准C++库中的所有类、对象和函数都是定义在名�I�间std下面的�?br>

你可能已�l�注意到�Q�我们在�q�个教程中全部忽略了�q�一炏V��作者决定这么做是因��条规则几乎和ANSI 标准本��n一样年�?(1997) �Q�许多老一点的�~�译器�ƈ不兼容这条规则�?br>

几乎所有的�~�译器，即��是那些与ANSI 标准兼容的编译器�Q�都允许使用传统的头文�g (如iostream.h, stdlib.h, �{�等)�Q�就像我们在�q�个教程中所使用的一栗��?br>

然而，ANSI标准完全重新设计了这些函数库�Q?br>利用了模板功能，
而且遵��@了这条规则将所有的函数和变量定义在了名�I�间std下�?br>

该标准�ؓ�q�些头文件定义了新的名字�Q�对针对C++的文件基本上是��用同��L��名字�Q�但没有.h的扩展名�Q?br>
例如, iostream.h 变成了iostream�?/p>

如果我们使用ANSI-C++ 兼容的包含文�Ӟ��我们必须��C��所有的函数、类和对象是定义在名�I�间 std 下面的，例如�Q?/p>

    // ANSI-C++ compliant hello world
            #include 
            int main () {
            std::cout << "Hello world in ANSI-C++\n";
        return 0;
    }

Hello world in ANSI-C++

更常用的�Ҏ��是��用using namespace �Q�这��h��们就不必在所有标准空间中定义的函数或对象前面��L��使用范围操作�W?:�?�Q?/p>

    // ANSI-C++ compliant hello world (II)
            #include 
            using namespace std;
            int main () {
            cout << "Hello world in ANSI-C++\n";
            return 0;
            }

Hello world in ANSI-C++

对于STL 用户�Q�强烈徏议��用ANSI-compliant 方式来包含标准函数库�?

henry08 2008-12-08 12:33 发表评论

模板与多文�g工程

henry08 — Mon, 08 Dec 2008 04:03:00 GMT

template // 最常用的：一个class 参数�?/font>

template // 两个class 参数�?/font>

template // 一个class 和一个整数�?/font>

template // 有一个默认倹{�?/font>

template // 参数��Z��个函数�?/font>

从编译器的角度来看，模板不同于一般的函数或类�?br>它们在需要时才被�~�译(compiled on demand)�Q?br>也就是说一个模板的代码直到需要生成一个对象的时�?instantiation)才被�~�译�?br>当需要instantiation的时候，�~�译器根据模板�ؓ特定的调用数据类型生成一个特�D�的函数�?br>

当工�E�变得越来越大的时候，�E�序代码通常会被分割为多个源�E�序文�g�?br>在这�U�情况下�Q?span style="COLOR: red">通常接口(interface)和实�?implementation)是分开�?/span>�?br>

用一个函数库做例�?br>     接口通常包括所有能被调用的函数的原型定义�?br>                                    它们通常被定义在�?h 为扩展名的头文�g (header file) 中；
      而实�?(函数的定�?
                                    则在独立的C++代码文�g中�?br>

模板�q�种�c�M��?macro-like) 的功能，对多文�g工程有一定的限制�Q?/span>
函数或类模板的实�?(定义) 必须与原型声明在同一个文件中�?br>也就是说我们不能�?��接�?interface)存储在单独的头文件中�Q?br>而必��d��接口和实现放在��用模板的同一个文件中�?/p>

回到函数库的例子�Q�如果我们想要徏立一个函数模板的库，我们不能再��用头文�g(.h) �Q�取而代之，我们应该生成一个模板文�?template file)�Q�将函数模板的接口和实现都放在这个文件中 (�q�种文�g没有惯用扩展名，除了不要使用.h扩展名或不要不加��M��扩展�?�?br>

在一个工�E�中多次包含同时��h��声明和实现的模板文�g�q�不会��生链接错�?(linkage errors)�Q�因为它们只有在需要时才被�~�译�Q�而兼�Ҏ��板的�~�译器应该已�l�考虑到这�U�情况，不会生成重复的代码�?/span>

henry08 2008-12-08 12:03 发表评论

静态成�?Static members)

henry08 — Thu, 04 Dec 2008 10:34:00 GMT

静态成员与全域变量(global variable)��h��相同的属性，但它享有�c?class)的范�?br>

C++ 标准�Q��ؓ了避免它们被多次重复声明�Q?br>在class的声明中只能够包括static member的原�?声明)�Q?br>而不能够包括其定�?初始化操�?�?br>��Z��初始化一个静态数据成员，
我们必须在class之外(在全域范围内)�Q?br>包括一个正式的定义�Q�就像上面例子中做法一栗��?/span>

在提醒一�ơ，它其实是一个全域变量。唯一的不同是它的名字跟在class的后面�?/p>

��像我们会在class中包含static数据一��P��我们也可以��它包含static 函数�?br>它们表示相同的含义：static函数是全域函�?global functions)�Q�但是像一个指定class的对象成员一栯��调用�?br>它们只能够引用static 数据�Q�永�q�不能引用class的非静�?nonstatic)成员�?br>它们也不能够使用关键字this�Q�因为this实际引用了一个对象指针，
但这�?static函数却不是�Q何object的成员，而是class的直接成员�?/p>

henry08 2008-12-04 18:34 发表评论

henry08 — Thu, 04 Dec 2008 10:04:00 GMT

实际上，当我们定义一个class而没有明��定义构造函数的时候，

�~�译器会自动假设两个重蝲的构造函�?br> (默认构造函�?default constructor" 和复制构造函�?copy constructor")�?br>

例如�Q�对以下class�Q?/p>

   class CExample {
     public:
       int a,b,c;
       void multiply (int n, int m) { a=n; b=m; c=a*b; };
   };


没有定义构造函敎ͼ�


�~�译器自动假讑֮�有以下constructor 成员函数�Q?/p>

    Empty constructor
    它是一个没有�Q何参数的构造函敎ͼ�被定义�ؓnop (没有语句)。它什么都不做�?/p>
    CExample::CExample () { };
    

    
Copy constructor
    它是一个只有一个参数的构造函敎ͼ�该参数是�q�个class的一个对象，�q�个函数的功能是���被传入的对象（object�Q�的所有非静态（non-static�Q�成员变量的值都复制�l�自�w�这个object�?/p>
    
    
   CExample::CExample (const CExample& rv) {
       a=rv.a;  b=rv.b;  c=rv.c;
   }
   

    


必须注意�Q?/strong>�q�两个默认构造函敎ͼ�empty construction �?copy constructor �Q?/p>
只有在没有其它构造函数被明确定义的情况下才存在�?/p>
如果��M��其它有�Q意参数的构造函数被定义了，�q�两个构造函数就都不存在了�?/p>
在这�U�情况下�Q?/p>
如果你想要有empty construction �?copy constructor �Q?/p>

��必需要自己定义它们�?/p>

henry08 2008-12-04 18:04 发表评论

henry08 — Thu, 04 Dec 2008 10:01:00 GMT
C在struct里面可以用public、private�Q�默认的是public�Q�而C++默认是private�?br>
C在struct里面可以用public、private�Q�默认的是public�Q�而C++默认是private�?

henry08 2008-12-04 18:01 发表评论

��法

henry08 — Thu, 27 Nov 2008 08:31:00 GMT
void main()
{
    long a1 = 34, a2 = 23, a3 = 12;
    if( a1 > a2 )
    {
        long temp = a1;
        a1 = a2;
        a2 = temp;
    }
    if( a1 > a3 )
    {
        long temp = a1;
        a1 = a3;
        a3 = temp;
    }
    if( a2 > a3 )
    {
        long temp = a2;
        a2 = a3;
        a3 = temp;
    }
}
上面��在每个if后面的复合语句中定义了一个��时变量temp以借助�~�译器的静态分配内存功能来提供临时存放卡片的内存。上面的元素交换�q�没有按照前面所说映��成函数�Q�是因�ؓ在这里其只有三条语句且容易理解。如果要��交换操作定义�ؓ一函数
如果要将交换操作定义��Z��函数�Q�则应如下：
void Swap( long *p1, long *p2 )             void Swap( long &r1, long &r2 )
{                                           {
    long temp = *p1;                            long temp = r1;
    *p1 = *p2;                                  r1 = r2;
    *p2 = temp;                                 r2 = temp;
}                                           }
void main()                                 void main()
{                                           {
    long a1 = 34, a2 = 23, a3 = 12;             long a1 = 34, a2 = 23, a3 = 12;
    if( a1 > a2 )                               if( a1 > a2 )
        Swap( &a1, &a2 );                           Swap( a1, a2 );
    if( a1 > a3 )                               if( a1 > a3 )
        Swap( &a1, &a3 );                           Swap( a1, a3 );
    if( a2 > a3 )                               if( a2 > a3 )
        Swap( &a2, &a3 );                           Swap( a2, a3 );
}                                           }
    先看左侧的程序。上面定义了函数来表�C�给定盒子之间的交换操作�Q�注意参数类型��用了long*�Q�这里指针表�C�引用（应注意指针不仅可以表�C�引用，�q�可有其它的语义�Q�以后会提到�Q��?br>

下面看右侧的�E�序。参数类型变成long&�Q�和指针一��P��依旧表示引用�Q�但注意它们的不同。后者表�C�它是一个别名，卛_��是一个映��，映射的地址是记录作为参数的数字的地址�Q�也��是说它要求调用此函数时�Q�给出的作�ؓ参数的数字一定是有地址的数�?br>

henry08 2008-11-27 16:31 发表评论

函数

henry08 — Wed, 26 Nov 2008 15:46:00 GMT

上面的返回类型�ؓvoid�Q�前面提�q�，void是C++提供的一�U�特�D�数字类型，其仅仅只是�ؓ了保障语法的严密性而已�Q�即��M��函数执行后都要返回一个数字（后面��说明）�Q�而对于不用返回数字的函数�Q�则可以定义�q�回�c�d��为void�Q�这样就可以保证语法的严密性�?/p>
可以认�ؓ函数�c�d��的地址�c�d��的数字编译器会隐式�{换成指针�c�d��的数�?/p>

重蝲函数表示函数名字一��P��但参数类型及个数不同的多个函�?/p>
声明是告诉编译器一些信息，以协助编译器�q�行语法分析�Q�避免编译器报错。而定义是告诉�~�译器生成一些代码，�q�且�q�些代码��由�q�接器��用�?/p>
extern long a, *pA, &ra;
    上面��声明（不是定义�Q�了三个变量a、pA和ra�?br>因�ؓextern表示外部的意思，因此上面��p��认�ؓ是告诉编译器有三个外部的变量�Q��ؓa、pA和ra�Q�故被认为是声明语句�Q�所以上面将不分配�Q何内存�?br>同样�Q�对于函敎ͼ�它也是一��L��Q?br>    extern void ABC( long ); �?nbsp; extern long AB( short b );

henry08 2008-11-26 23:46 发表评论

henry08 — Wed, 26 Nov 2008 07:52:00 GMT
数组和指针都是类型修饰符�Q�之前提�q�的引用变量�?#8220;&”也是�c�d��修饰�W?br>
指针修饰�W?#8220;*”——其��L��接在变量名的前面�Q�表�C�当前类型�ؓ原类型的指针。故�Q?br>short a = 10, *pA = &a, **ppA = &pA;

引用修饰�W?#8220;&”——其��L��接在变量名的前面�Q�表�C�此变量不用分配内存以和其绑定，而在说明�c�d��Ӟ��则不能有它，下面说明。由于表�C�相应变量不用分配内存以生成映射�Q�故其不像上�q�C��U�类型修饰符�Q�可以多�ơ重复书写，因�ؓ没有意义

henry08 2008-11-26 15:52 发表评论

henry08 — Wed, 26 Nov 2008 07:40:00 GMT
unsigned long *pA = new unsigned long; *pA = 10;
unsigned long *pB = new unsigned long[ *pA ];

上面��q��请了两块内存�Q�pA所指的内存�Q�即pA的值所对应的内存）�?字节大小�Q�而pB所指的内存�?*10=40字节大小。应该注意，�׃��new是一个操作符�Q�其�l�构为new <�c�d��?gt;[<整型数字>]。它�q�回指针�c�d��的数字，其中�?lt;�c�d��?gt;指明了什么样的指针类型，而后面方括号的作用和定义数组时一��P��用于指明元素的个敎ͼ�但其�q�回的�ƈ不是数组�c�d��Q�而是指针�c�d��?br>

delete pA; delete[] pB;

    注意delete操作�W��ƈ不返回�Q何数字，但是其仍被称作操作符�Q�看��h��它应该被叫做语句更加合适，但�ؓ了满��_��依旧是操作符的特性，C++提供了一�U�很�Ҏ��的数字类型——void。其表示无，即什么都不是�Q�这在《C++从零开始（七）》中��详�l�说明。因此delete其实是要�q�回数字的，只不�q�返回的数字�c�d��为void�|�了�?br>
    注意上面对pA和pB的释放不同，因�ؓpA按照最开始的书写�Q�是new unsigned long�q�回的，而pB是new unsigned long[ *pA ]�q�回的。所以需要在释放pB时在delete的后面加�?#8220;[]”以表�C�释攄��是数�l�，不过在VC中，不管前者还是后者，都能正确释放内存�Q�无需“[]”的介入以帮助�~�译器来正确释放内存�Q�因��Z��Windows为��^台而开发程序的VC是按照Windows操作�pȝ��的方式来�q�行内存分配的，而Windows操作�pȝ��在释攑ֆ�存时�Q�无需知道�Ʋ释攄��内存块的长度�Q�因为其已经在内部记录下来（�q�种说法�q�不准确�Q�实际应是C�q�行时期库干了这些事�Q�但其又是依赖于操作�pȝ��来干的，卛_��实是有两层对内存��理的包装，在此不表�Q��?br>

henry08 2008-11-26 15:40 发表评论

指针

henry08 — Wed, 26 Nov 2008 07:39:00 GMT

再来看取内容操作�W?#8220;*”�Q�其��x��的数字类型是指针�c�d��或数�l�类型，它的计算��是��此指针�c�d��的数字直接�{换成地址�c�d��的数�?br>因�ؓ指针�c�d��的数字和地址�c�d��的数字在数��g��是相同的�Q�仅仅计��规则不�?/p>

地址�c�d��的数字是在编译时期给�~�译器用�?br>指针�c�d��的数字是在运行时期给代码用的

henry08 2008-11-26 15:39 发表评论

henry08 — Wed, 26 Nov 2008 07:38:00 GMT

在申请内存时��L��甌��固定大小的内存，则称此内存是静态分配的。前面提出的定义变量�Ӟ��~�译器帮我们从栈上分配的内存��属于静态分�?/p>

�Ҏ��用户输入的不同而可能申请不同大��的内存�Ӟ��则称此内存是动态分配的�Q�后面说的从堆上分配��属于动态分配�?/p>

同样�Q�静态分配的内存利用率不高或�q�用不够灉|��Q�但代码�Ҏ��~�写且运行速度较快�Q�动态分配的内存利用率高�Q�不�q�编写代码时要复杂些�Q�需自己处理内存的管理（分配和释放）且由于这�U�管理的介入而运行速度较慢�q�代码长度增加�?br>静态和动态的意义不仅仅如此，其有很多的深化，如硬�~�码和��Y�~�码、紧耦合和松耦合�Q�都是静态和动态的深化�?br>

henry08 2008-11-26 15:38 发表评论

字符�?

henry08 — Wed, 26 Nov 2008 07:37:00 GMT

char�c�d��q�行表示的字�W�串�U�Cؓ单字节字�W�串�Q�SingleByte�Q�，用这�U�表�C�方式记录的文本文�g�U�Cؓ是ANSI格式�?br>

  多字节字�W�串�Q�MultiByte�Q�，用这�U�表�C�方式记录的文本文�g�U�Cؓ是MBCS格式�?br>

宽字节字�W�串�Q�WideChar�Q�，用这�U�表�C�方式记录的文本文�g�U�Cؓ是Unicode格式�?br>         (一个short�c�d��的数字来表示�Q�即每个字符的长度固定�ؓ2字节)

henry08 2008-11-26 15:37 发表评论

henry08 — Wed, 26 Nov 2008 04:35:00 GMT

下面的网址是最有名的两个在�U�C++�~�译�|�站�Q?/p>
http://www.dinkumware.com/exam/default.aspx
http://www.comeaucomputing.com/tryitout/
许多在线判题�pȝ��也可以用来进行在�U�编译：

http://acm.zju.edu.cn/
http://acm.pku.edu.cn/JudgeOnline/
http://acm.uva.es/
你可能会好奇�q�些�|�站使用的编译器的版本和�~�译参数到底是什么。有些网站会提供�q�些信息�Q�而有些则不会。那么你��只能靠自己��d��现这�?#8220;�U�密”了�?/p>
工欲善其事，必先利其器。让我们先看看一些从�~�译器获取信息的��技巧�?/p>
1. 输出�?br>在C++中，字符串常��C��能作为模板参数。大多数�~�译器会在错误信息中同时输出字符串的内容。下面的代码展示了这一技巧�?

template class A {};
#define F0(x) #x
#define F1(x) F0(x)
#define V1 F1(__GNUC__)
int main()
{
    A a1;
}

�q�里�Q�宏F0和F1用于��整型�{换成字符丌Ӏ�编译器会输出类��g��"literal "3" is not a valid template argument because it is the address of an object with static linkage"的出错信息。里面的"3"��是你想知道的宏的内宏V�?

2. 输出常数
同样�Q��Q�Ҏ��是不能作为模板参数的。编译器通常会在错误信息中包含��Q�Ҏ��的倹{��利用这一点，我们可以输出��点常数。不�q�很不幸的是�Q�VC会隐式的��Q点类型的模板参数转换成int�Q�参�?a >https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=296008�Q?br>下面是一�U�输出整型常量的�Ҏ��Q?

template
class A
{
private:
    A();
};
int main()
{
    A a;
}

3. 输出变量�c�d��
有时候，你可能需要知道某些变量的实际�c�d��Q�这时候你可以使用下面的代码：

struct Dummy {};
void Fun(const Dummy &);
int main()
{
    Fun(1+1U);
}

PS�Q�如果你使用的是gcc�Q�那么它会输�?not convert `2' to `const Dummy&'"�Q�所以你需要将Fun的声明改�?template void Fun(T);"�Q�换句话��_��在gcc中上面的代码也可以用于输出常数的��|��

4. 输出包含路径
如果要获取STL头文件的路径�Q�你可以使用�Q?

#include
using __gnu_cxx::hash_set;

int main()
{
    hash_set<> m;
}

PS�Q�这里也可以使用vector�?

好，现在是时候牛刀��试了。关于如何获取编译器的版本信息，可以参考这��文章：Pre-defined Compiler Macros

下面是利用上面介�l�的技巧获得的dinkumware�|�站的一些资料：

1. VC
版本 (_MSC_FULL_VER)�Q?br>         VC8 140050727
         VC7.1 13103077
         VC7 13009466
         VC6 12008804
包含路径�Q?
         D:\cplt501_vc_source\include (with _CPPLIB_VER=501)

2. EDG
版本(__EDG_VERSION__):
         3.05
�~�译参数�Q?br>         edgcc --alt -D_WIN32 -D_M_IX86 --no_inlining --diag_suppress=1290 --long_long --wchar_t_keyword -D_C99 -ID:\cplt501_gen_source/include/c -ID:\cplt501_gen_source/include -IC:\PROGRA~1\MICROS~2.NET\VC7/include --exceptions --microsoft -c sourceFile.cpp
因�ؓ使用了VC兼容模式�q�行�~�译�Q�所以编译器可能会模拟VC的部分bug

3. GCC
版本�Q?br>         3.2.0
包含路径�Q?br>         D:/cplt501_gen_source/include and D:/Mingw/include/c++/3.2/
可以看到�q�里使用的GCC的版本已�l�相当陈旧了

文章出处�Q?a >http://www.diybl.com/course/3_program/c++/cppsl/2008108/149011.html

henry08 2008-11-26 12:35 发表评论

henry08 — Tue, 25 Nov 2008 16:18:00 GMT

赋��D��?br>因此应在变量定义的时候就�q�行赋��|��但是会有性能上的影响�Q�不�q�很��）�Q�以初始化变量而防止出现莫名其妙的�?在表辑ּ�中运用赋��D��符是不好的�Q�即使它可能让你写出看�v来简�l�的语句�Q�但它也使代码的可维护性降低�?/p>

true 0
false �?

henry08 2008-11-26 00:18 发表评论

henry08 — Mon, 24 Nov 2008 10:45:00 GMT

C++卛_��许程序员有两�U�向操作�pȝ��甌��内存的方式�?br>    前一�U�就是在栈上分配�Q�申��L��内存大小固定不变�?br>    后一�U�是在堆上分配，甌��的内存大��可以在�q�行的时候变�?/span>�Q�不是固定不变的
_______+++++++++++++++++++++++++++++++++++_____________________________

栈（Stack�Q?br>
                  : ��M��E�序执行前，预先分配一固定长度的内存空��_��
                    �q�块内存�I�间被称作栈,也被叫做堆栈
                    即程序员自己判断可以使用哪些内存�Q?br>                    �?span style="COLOR: red">不是操作�pȝ��,很明显，
                   上面的工作是��q��译器来做的，
                   工作只是从操作系�l�变到程序自��p��已,
                   好处��是�׃��E�序一开始执行时��已�l�分配了一大块�q�箋内存,
                   坏处也就是只能在�~�译时期分配内存

上面的工作是�~�译器做的，即程序员�q�不参与堆栈的维护。但上面已经说了�Q�堆栈相当于在编译时期分配内存，因此一旦计��好某块内存的偏�U�，则这块内存就只能那么大，不能变化�?br>

__________________________________________________________________________________________________

堆（Heap�Q?br>
                 在Windows操作�pȝ��下，�?span style="COLOR: #ff0000">操作�pȝ��分配的内存就叫做�?/span>�Q?br>                 而栈可以认�ؓ是在�E�序开始时��分配的�?br>                 因此在堆上就可以分配大小变化的内存块�Q?br>                 因�ؓ�?span style="COLOR: #ff0000">�q�行时期��x��分配的内存，
                �?span style="COLOR: #ff0000">不是�~�译时期已计��好大小的内存块�?br>

henry08 2008-11-24 18:45 发表评论

c++ 开blogs

henry08 — Tue, 11 Nov 2008 07:35:00 GMT
c++ 开blogs

henry08 2008-11-11 15:35 发表评论

国产2021久久精品,国产精品VIDEOSSEX久久发布,国产福利电影一区二区三区久久久久成人精品综合

4. 对象

5. 函数

6. 向量Vector

8. 指针pointer

9. �l�承

正确的方法是定义operator++以reference为参数类�? C++中Reference与指针（Pointer�Q�的使用�Ҏ��

References vs. const pointers

Null references

Null references

更安�?

参考资料：

VC6.0中重载操作符函数无法讉K���cȝ���U�有成员

�c�d��转换高�� (Advacned Class Type-casting)

reinterpret_cast

static_cast

dynamic_cast

const_cast

typeid

名空�?(Namespaces)

标准名空�?Namespace std)

模板与多文�g工程

静态成�?Static members)

���法

函数

指针

字符�?

c++ 开blogs

VC6.0中重载操作符函数无法讉K��cȝ��U�有成员

��法