考虑如下代码：

#include <iostream>
using namespace std;

int main()
{
  int a;
  while(cout<<"input a integer (1- 10) :",cin>>a,! (a>=1 && a<=10))
   cout<<"try again!"<<endl;
return 0;
}

本意是让用户选择一个1-10的数，如果不是1-10的数则重新输入。

分析：

如果用户输入了一个不在1-10的 int，那么，程序会正确的执行，并且提示用户重新输入。

但是如果用户错误的输入了一个字符char，那么，后果就是一直执行while循环！

错误分析：

当cin尝试将输入的字符读为int型数据失败后，会产生一个错误状态--cin.fail().而要用cin读取输入流中的数据，输入流必须处于无错误状态。因此，由于错误状态的存在，会一直执行while循环。

错误修正：

#include <iostream>
using namespace std;

int main()
{
int a;
while(cout<<"input a integer (1-10) :",cin>>a,! (a>=1 && a<=10) || cin.fail())
{
   cout<<"try again!"<<endl;
   cin.clear(); //清除std::cin的错误状态
   cin.sync(); //清空输入缓冲区
}
return 0;
}

加上判断输入是否成功的cin.fail()以及修正错误输入的cin.clear()和cin.sync();

其中std::cin.sync();这一句必不可少，因为所有从标准输入设备输入的数据都是先保存在缓冲区中，然后istream对象再从缓冲区中进行提取。如果不清空缓存，下次在读取数据的时候又会再次产生错误，也会陷入死循环。

    题记：一直以来都被一些细节忽略了，然后，遇到很多的问题就杯具了……从现在开始，觉得很有必要从小事做起，认真的来看看曾经犯过的错误，做过的事情。特别是对于曾经以为很习以为常的事情，要特别的重视，于是便有了tips，下面不断的更新中…………

题外话：（如何在Office 2007中创建并发布博文？）今天发现可以在Word 2007中编辑博客，然后直接点击发布，就可以发布到C++博客网上了，很贴心的服务，不是吗？其实这个也是Office的一个功能，在新建中，点击新建博客文章，就可以创建一个新的blog，然后会提示你创建一个账户，估计这个是最关键的，需要选择其他运营商，然后下一步，会有个API让你选择，选择下面的按个MetaWebLog，然后输出你的账号密码，这里的昂URL，不是你的主页的，开始的时候我也是选择这个，错误，连接不上。需要的是：在你的主页上，点击管理，然后点击选项，下面有个configure选项，进入后，最下面就有一个你的那个URL了，添加进去，OK！然后就可以发布了！

下面开始正式的tips：

1. int到底占用多少个字节？

   一直以来都被这个问题纠结，因为上过汇编和C的课，然后又看了《C++ Primer》一书，总是会出现各种的不一致，如果按照平时我们的认为，都是4个Byte（字节），可是无奈很多书上讲解不一致，所以造成了迷惑……今天找时间上网搜了下，发现答案很多，不过大致上都是一个解答，于是我也就凭借自己的思考，来说说了。

   答：首先摘录网上的朋友们的留言：

综合上面的说法，我也觉得对于int到底占用多少个字节，其实是和机器以及编译器都有关系。这么来说吧，我觉得机器起决定性作用，如果是32位机，那么在这个平台上面运行的编译器，可以使32位版本的，也可以是16位版本的（向下兼容，只不过浪费了好机子，没有充分发挥效果），这也就是说我们在网上下载驱动的时候，有时候会发现官网上面有32位操作系统Windows版本和64位操作系统Windows的不同分类了。而决定这个位数的，就是你的CPU，也就是机器。

但是，编译器没有必要一定要这么做，对于TC 2.0这样的16位软件，曾经在Dos下呼风唤雨，但是到了32位机下，仍然是可以用的，这样的话，也就是说，它运算的结果是2个字节，可是因为软件的限制，只能够模拟出来16位机，所以虽然可以在32位上面跑，但是不能反映实际的字长。但是，没有多少人会在32位机子上面模拟出128位或者64位，因为这样寻址的话效率很低下，硬件条件没有达到，利用软件来模拟是不够的。于是，就是上面的那种说法。由于VC以及其他软件更新很快，而且及时开发了Win 32下的版本，所以是32位软件，也就是说，它计算处理的int是4个字节。

当然，我们需要知道的是，标准并没有规定int一定要是多少个字节，而只是规定了一个范围，只要你不越轨，那么肯定就没有问题，至于实现，那是你编译器的开发的事情，跟我无关。同样，CPU和机器的制造者，关心的是如何提高计算机的性能，让寻址方式更大，范围更长，也就是位数越多，（这也是为何目前的那些机器都朝着64位或者更高位发展的目的），而软件开发者，面临的则是需要来适应硬件的更新，从而做出更好的软件，充分利用到这个性能。

当然，这个问题本身没有多少讨论的价值，不过，如果在面试或者考试中，遇到sizeof的操作，最好问清楚是在32位机子下还是16位或者是64位，这个能够反映你的严谨和认真。

注： 32位下：1int = 4 Byte            16位下：1 int = 2B        (当然，一般都不会考虑那个TC 2.0的)

2).普通类的继承中，如果派生类中的函数和基类函数同名时，是否会覆盖原来的那个函数？

    在java中，很明显是会覆盖的，因为继承的特性，注意同名函数，要求还有原型相同，否则的话，调用的时候是可以区分开来的，而当原型相同的时候，那么派生类会继承基类的函数，同时由于有一个自己的函数，所以两个同名，同原型的函数，是会发生覆盖的。

上代码看之：

输出的结果是：

从上面的结果可以看到，派生类的指针是调用派生类的对应的函数，配套的，而且还选择作用域较小的，而这样的优先级就要高些。这里有一个强制类型转换，因为是要将派生类的指针指向基类的对象，会发生截断，所以一定要强制类型转换，与此对比的是，基类的指针指向派生类的话不需要强制类型转换也可以实现。从结果可以看到，如果实行了转换，那么还是声明时候的类型，所以抓住了这点，声明时是B类型的，那么就调用B的moveto，所以输出时2，下面的另外一些的输出，就都是1了，也可以看到，如果要显示的调用被隐藏的基类，需要用作用域限定符来指示。

 2.隐藏的this指针不是实际的一个参数，也就是说，实际调用函数中，不能够使用这个参数。
上代码：

#include <string.h>
#include <iostream>
using namespace  std;

class STRING{
    char *str;
public:
    STRING(char *s=0);
    STRING(const STRING &);
    virtual int strlen(void) const;
    virtual int strcmp(const STRING &) const;
    virtual STRING &operator+(const STRING &);
    virtual STRING &operator=(const STRING &);
    virtual STRING &operator+=(const STRING &);
    virtual operator const char *(void) const;
    virtual ~STRING();
};

STRING::STRING(char *s/**//*=0*/){
    str = new char[::strlen(s)+1];
    ::strcpy(str,s);
}
STRING::~STRING(){
    delete str;
}
int STRING::strlen(void) const{
    return ::strlen(this->str)+5; //采用字符串的通用表示，不含null
}
int STRING::strcmp(const STRING &b) const{
    return ::strcmp(this->str,b.str);
}
STRING &STRING::operator+(const STRING &b){
    ::strcat(this->str,b.str);
    return *this;
}
STRING &STRING::operator=(const STRING &b){
    this->str = b.str;
    return *this;
}
STRING &STRING::operator+=(const STRING &b){
    ::strcat(this->str,b.str);
    return *this;
}
STRING::operator const char *(void) const{
    return this->str;
}
int main()
{
    STRING s("Hello,world");
    STRING e("I Love C++");
    cout << "STRING:" << s << "\t strlen:" << s.strlen()<< endl;
    cout << "STRING:" << e << "\t strlen:" << strlen(e)<< endl;
    
    return 0;

}

  仅仅看输出，前面的一个是调用类函数strlen，没有参数，看到没有，如果有参数的话，就是下面的那个，那么此时就是调用的系统函数了。两者的输出不一样，我特意在自定义的strlen函数上面加5以表示区别，最后果然，前者就是调用自己的函数。
得到的结论就是，类的成员函数，都是有一个默认的this指针的，这个没有错，不过这个是编译器加的，我们手动是不能自己占有的，也就是说不能理解为有一个参数，然后放上面去，自己定义的是void参数，就没有参数，编译器加的是它的事情，那个地方提供给我们用户使用的就是无参的函数。此点要铭记，而且，即使你调用无参的，在具体编译器处理的时候，还是会给你加上，所以这部分你根本用不上，也不需要担心。

在C++中，如果出现函数的形参和类的数据成员同名的情况，一定不要为了图简省而使用下面的写法。例：

在红色部分突出显示的就是错误的写法，实际上，形参的值根本没有传入到这个函数中，而在你输出的时候，根本没有x，y的值，也就是一个随机的。说明形参根本没有传入。

这个也是Java中遇到的，如果有这种情况，java中用到的是this引用来显示的圈定范围，而C++中，也需要用this指针来显示的解决这个问题。或者用作用域限定符来解决。

更改后才会出现正确的结果，而以前，自己一直都没有注意到。

为何会这样呢？因为按照范围从小到大的顺序，形参的范围更小，所以替换的就是恒等式，那么自然不会显示的来给成员赋值，因为类的成员作用范围更小，此处，要谨记。

而且对于Java也是一样，都要显示的来指出。

a.       常量型成员变量

b.       引用型成员变量

c.        静态成员变量

d.       整型静态常量成员变量

e.       非整型静态常量成员变量

对于常量型成员变量和引用型成员变量的初始化，必须通过构造函数初始化列表的方式进行。在构造函数体内给常量型成员变量和引用型成员变量赋值的方式是行不通的。

静态成员变量的初始化也颇有些特别。

参考下面的代码以及其中注释：

// Initialization of Special Data Member

#include <iostream>

using namespace std;

class BClass

{

public:

         BClass() : i(1), ci(2), ri(i)   // 对于常量型成员变量和引用型成员变量，必须通过

         {                                             // 参数化列表的方式进行初始化。在构造函数体内进

         }                                             // 行赋值的方式，是行不通的。

         void print_values()

         {

                   cout << "i =\t" << i << endl;

                   cout << "ci =\t" << ci << endl;

                   cout << "ri =\t" << ri << endl;

                   cout << "si =\t" << si << endl;

                   cout << "csi =\t" << csi << endl;

                   cout << "csi2 =\t" << csi2 << endl;

                   cout << "csd =\t" << csd << endl;

         }

private:

         int i;                                                          // 普通成员变量

         const int ci;                                             // 常量成员变量

         int &ri;                                                      // 引用成员变量

         static int si;                                             // 静态成员变量

         //static int si2 = 100;                             // error: 只有静态常量成员变量，才可以这样初始化

         static const int csi;                                // 静态常量成员变量

         static const int csi2 = 100;                  // 静态常量成员变量的初始化(Integral type)    (1)

         static const double csd;                      // 静态常量成员变量(non-Integral type)

         //static const double csd2 = 99.9;      // error: 只有静态常量整型数据成员才可以在类中初始化

};

// 静态成员变量的初始化(Integral type)

int BClass::si = 0;

// 静态常量成员变量的初始化(Integral type)

const int BClass::csi = 1;

// 静态常量成员变量的初始化(non-Integral type)

const double BClass::csd = 99.9;

// 在初始化(1)中的csi2时，根据Stanley B. Lippman的说法下面这行是必须的。

// 但在VC2003中如果有下面一行将会产生错误，而在VC2005中，下面这行则可有可无，

// 这个和编译器有关。

const int BClass::csi2;

int main(void)

{

         BClass b_class;

         b_class.print_values();

         return 0;

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/pathuang68/archive/2009/11/25/4867323.aspx

C/C++中的字符串字面值

1.     字符串数组的大小如何得到。我们都知道，对于一个字符串数组，要得到它的大小，有多种办法，常见的有下面的两种。

Ⅰ.利用sizeof运算符来实现。现在假设有一个字符数组str[] = “hello,world”,为了得到的它的长度，我们利用这种办法

具体就是sizeof(str) /sizeof(char);结果是12，比较发现，实际的字符串大小事11啊，为什么会得到12的结果呢？

有这种疑问，是因为对我们字符数组没有一个更好的理解。上面初始化一个字符数组，是利用字符串来初始化的，

而字符串的话，默认的是会有一个以null结尾的标志，这个具体的就是’\0’,有很多人的程序有问题，可能都是因为这里

出现了问题，比如数组没有封口，造成了指针非法访问其他内存单元，等等。所以实际上的长度就是12.

具体来说说这个原理吧：sizeof是表示计算大小，即字节数。这里以一个数组名来作为参数，就是计算这个数组的大小。

上面说到，字符串数组的话是有一个默认的null来封口的，所以，计算的大小事包括这个单元的。于是sizeof(str)的大小

就是12 个字节，然后计算一个单元，即一个字符char类型的占据的字节数，也就是1个字节，两者相除，就是12的结果。

Ⅱ.利用循环来实现，这个部分是很多人都常常想到的。因为一个字符串来定义的数组，默认是以null即为的，所以，通过               循环遍历的方式来实现，这个方法还是可行的。定义一个变量i，然后利用for循环，判断str[i]不为’\0’，即可判断              得到最后一个元素的下标，注意到的是这里是最后一个字符元素，但是不是最后一个真正的元素，有一个null，因此，还                要加上1才是真正的个数，经过这个过程，得到的就是总的长度。这个方法比较容易理解。但是容易忽略了最后一个的作用。                                                                                                实际上，我们使用的很多C提供的函数，关于字符串操作的，都需要用到这个知识，我们在做计算的时候，很容易误以为返                    回的。就是那个字符串的长度，从而导致了错误。实际在我们拷贝字符串的时候，尤其要注意这一点。

2.  在《C++ Primer》一书中，将以null结束的字符数组称为字符数组，标准库提供一批处理这类字符数组的函数，包括strlen,strcmp,strcat,strcpy,strncat,strncpy等等，而这些函数中的参数，都是以null结束的字符数组名，也就是字符数组的指针，而得到长度，返回的就是一个长度，没有包括null这个单元，所以实际上，上面的那个还有一个方法，可以调用此函数来实现。当然，还有一点要注意的是，strcat连接函数，将右边的字符串连接到左边，所以对于左边的字符串，一定要准确的计算出长度，如果不慎，就会溢出，出现严重的错误。看看下面这个例子：

Char s1[25] = “hello,world”;  char s2[20] = “0123456789012345678”(刚好是20个字符，为何，因为有一个null).所以现在的那个s2[20] = “01234567890123456789”,此时你会发现，字符串就有20个，含有一个null，注意就溢出了，OK。

下面，如果我将上面的那个采用字符串连接函数来做，就是strcat(s1,s2)，那么又会出现错误。因为溢出了。

3.C++中提供了一个标准库string来处理字符串，这个string类提供了很多操作，是一种更安全的做法，然而了，为了新旧代码的兼容，需要进行两者之间的转换，而把string的一个类函数c_str()返回值是C风格字符串。const char *str = st2.c_str();其中st2是一个string类型的对象，返回值就是一个指向它的字符串。 此即为字符串的处理，作为C/C++的字符串值得注意的地方。                                                 

1．操作系统的实验基本上都是以linux下面的系统编程为内容，进程的调度和创建都是很基本的内容。很幸运的是，linux为我们提供了很多的系统函数，供我们来使用。通过熟悉这些函数，使得我们可以能够对进程和程序有一个更良好的认识。

2．Fork函数的使用。下面引用自百度百科：

1.      下面来详细的说说我的程序和问题，通过比较学习，相信对于linux的学习，特别是进程和程序直接的关系有一个更好的理解。

Process2.c

Code：

#include <stdio.h>

#include <unistd.h>

int main()

{

 int p1;

 p1=fork();

 if (p1 == 0)      //子进程，输出它的父进程和当前进程的PID

 {

     printf("current PID is %d\n",getpid());

     printf("father PID is %d\n",getppid());

     printf("\n");

 }

 else   //这里是父进程吗？

 {

     printf("father PID is %d\n",getppid());

     printf("current PID is %d\n",getpid());

     printf("\n");

 }

 return 0;

}

分析：此进程的运行结果是？（思考后再回答）

是的，有两种情况。首先，程序运行到fork语句之后，创建进程，此时有两种情况，创建成功和不成功，而成功又有两种情况，fork的返回值为0，则运行的是创建的子进程，fork的返回值为1，则运行的是父进程。用if语句来判断，OK。

那么问题就是，if语句中没有问题，p1为0，说明创建成功，运行的是子进程，可是else语句来说，却又两种情况，如果创建不成功也在else语句中，那么此时当前进程就是那个原始的进程，而它的父进程却是1号PID，因为所有的进程都是1号进程的子进程，这个是linux下面的结论。操作系统的知识。

所以，此时的结果应该是：

先放着，先解释下面的这个，注意，这个对上面是有帮助的。

（看完之后回头过来看看），看到没有，首先输出的那个father PID是什么，刚好就是下面的那个32667，这个不是偶然的，说明什么，当然，这个进程就是父进程，而创建它的那个进程的PID是32667，可以认为是系统创建的。就是说这种情况下面是，先运行的父进程。而它创建失败了，那么它没有子进程啊，那么那个下面的这个进程的父进程就不是上面的那个了，为何，从结果可以看到，它的PID是1，而不会是15254，说明不是上面的那个创建。而创建却是1，说明是系统创建的，所以fork语句之后，没有创建成功，而是由系统来亲自创建一个进程，所以PID号当然是下一个，不过父进程就是1号了。（有兴趣的可以查阅下资料，我们也是刚学，所以我还有继续探究中！！）

PID = 13501 父进程

PID = 13504 子进程

系统创建了当前的那个父进程，就是程序运行的进程 PID = 32667

 

下面还想讨论这样一个问题，这个问题是从上面那个第一种情况引申来的。

如下：

Code：

结果如下，虽然比较多，不过很能说明问题：

看完了上面的那个例子，下面的这个例子就是小case了，当然，其实上面的那个例子就是由下面的这个例子引申来的，是因为写错了代码而引起的。当然，根据错误，我们收获不小啊！

Code：

结果如下：

因为我们希望使用到类的一些操作，使得一个类更像内置的数据类型（int，float…………）

比如说对于int类型的变量，自增运算符是默认的，即定义int i，即可以用到i++，而现在对于自定义

的一个类，如果没有定义++操作，那么程序时不会找到这个操作的相应定义的，更不会执行相应的操

作！

也就是说，实际上重载运算符是给了++…………这些运算符一些新的定义和操作，结果很明显，我们

使用自定义类的时候可以像内置类型一样那么自然，简单，符合我们的用户习惯！

2.如何定义重载运算符？

前面说到重载，对，对于一个运算符，实际上语言的本身是定义默认的操作的，比如说加法运算，对于int类型可以知道是整数相加，对于float类型也是如此，这实际上也是一种重载，对于不同类型的数据，可以用同一个运算符来重载！

现在我们的问题是要增加自己定义的类的操作。

OK，言归正传，有两种定义的方法，使用类内置成员函数的方法和友元的方法来定义：

运算符的重载形式有两种：重载为类的成员函数和重载为类的友元函数。

总括：此部分写的还是比较好，特别是第一章，介绍了面向对象编程的特别，关键是从一个解决问题的角度来分析，相比较而言，C++ Primer更显得杂乱无章。通过对问题深入，根据解决问题的方法，来实现最合理化的得到目的，从而引出继承等等一系列概念和手段。

1.     构造器

2.     继承的细节

对于类的几点认识：
---------《以下的几条规范是便于多文件管理，分别编译的》---------
1.将类的声明放在h文件中，注意是声明，而不是定义，命名之，最好用类

名来给这个h文件命名。
2.将类的定义放在cpp文件中，单独一个cpp文件中，以类名命名之。
3.将主函数放在单独一个文件cpp中，文件名无所谓，不过取main的话便于

找到主体程序在哪里。

下面要说的是虚函数：virtual
1.在类中要声明virtual，但是放在对应的定义cpp文件中的时候，要注意去

掉virtual，否则会报错。
2.注意声明和定义的原型都必须完全一样，比如声明中有一个const，那么

在定义中必须也要有，否则的话就会报错，说不认识这个函数。
3.在类外定义的话一定要加上类型限定符，作用域限定符。

 下面写点代码：

student.h头文件 
1#ifndef STUDENT_H
 2#define STUDENT_H
 3
 4#include <iostream>
 5using std::string;
 6
 7
 8class Student
 9{
10public:
11    Student(const string& a="",double b=0.0,int c=0):score(b),name(a),number(c)
12    {}
13    ~Student(){}
14    //void show_score();
15    //void modify(Student& a);
16    friend Student operator+(Student& a,Student& b);
17    friend Student operator-(Student& a,Student& b);
18    friend std::ostream& operator<<(std::ostream &a,Student& b);  //改变状态的一般都要定义为类成员，++，--及*
19    friend std::istream& operator>>(std::istream &a,Student& b);//进行算术运算和输入输出的就定义为友元
20    //Student& operator=(Student& a);
21private:
22    double score;
23    string name;
24    int number;
25};
26
27#endif

 1student.cpp文件，实现类函数
 2#include <iostream>
 3#include <string>
 4#include "Student.h"
 5using std::cout;
 6using std::cin;
 7using std::endl;
 8
 9Student operator+(Student& a,Student& b) //这里面又用到了<<这个运算符的。而这个你已经自定义了啊！
10{
11    cout << a.name << "和" << b.name << "分数之和为:" << a.score+ b.score;
12    cout << endl;
13    return a;
14}
15Student operator-(Student& a,Student& b)
16{
17    cout << a.name << " 比 " << b.name << "多" << 
18        (a.score > b.score)?(a.score-b.score):(b.score - a.score);
19    cout << endl;
20    return a;
21}
22std::ostream& operator<<(std::ostream &a,Student& b)
23{
24    a << b.name<<"的分数：" << b.score << "\t 学号：" << b.number << endl;
25    return a;
26}
27std::istream& operator>>(std::istream &a,Student& b)
28{
29    a >> b.name >>b.number >> b.score  ; 
30    return a;
31}
32/**//*
33问题1，修改定义函数的时候没有修改声明，为什么这么粗心呢？
342.返回值，特别是对于有输入输出流的，要有返回值啊！
353.流的返回值和调用。
364.返回值怎么能为void呢？因为要输出a+b，所以要返回一个值啊，相当于opreator+(a,b)
37*/

主函数：main.cpp 
1#include <iostream>
 2#include "Student.h"
 3
 4using namespace std;
 5
 6int main()
 7{
 8    Student a,b;
 9    cout << "依次输入姓名，学号，成绩" << endl;
10    cin >> a >> b;
11    cout << a << b;
12    cout << endl;
13    return 0;
14}
15

 我想说的是自己遇到的几个问题：
1.重载<< 和>>操作符：这两个操作符只能作为友元而不是成员函数。作为重载运算符，有两种定义形式，即：成员函数形式和非成员函数形式，对于成员函数的形式，它的声明方式是形参数要比操作数少一个，为什么呢，因为省略了默认的形参this指针，而这个省略的形参正式左操作数，即定义这样的运算符的时候，this指针指向的是左操作数。其次，就是非成员函数，即友元声明方式。友元声明方式较简单合理，形参数和操作数相同，显示的是合理的调用函数的方式。
2.什么时候用成员函数的声明方式，什么时候用友元函数的声明方式？此部分需注意的是：1，对于=，（），【】，->这四个操作符只能作为成员函数来声明，想想这个是为什么呢？
  (1)只能使用成员函数重载的运算符有：=、()、[]、->、new、delete。
  (2)单目运算符最好重载为成员函数。
  (3) 对于复合的赋值运算符如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建议重载为成员函数。
  (4) 对于其它运算符，建议重载为友元函数。
关于此问题的详细讨论，见：http://www.rupeng.com/forum/thread-4468-1-1-uid3573.html
在C++编程思想中有述，据网友而言，大意是：如果可以定义为全局变量的话，那么就可以定义为int operator =(int,mytype),而这种方式的话就不对了，因为赋值=是和左边的类紧密相连的，所以会定义为成员函数的……

 此部分详细关注中………………

3.关于重载运算符的返回值的问题：
我们是不是已经习惯于重载运算符有一个返回值类型呢？对，是的，我们经常这么干，现在的问题是，如果我定义为void的话，会出错吗？
不会的，将上面的换成void的返回值照样不会出错！
为什么呢？因为定义有返回值只是我们的一个习惯，为何有返回值，因为我们要返回值，很白痴吧？可是事实就是这样，想想这个：
cout << a + b;  这个代码很简单是吧，a+b 实际上就是operator+（a,b）的一个等价形式,我要能够cout ，那么必然有一个返回值，否则的话调用这个函数没有返回值的话我怎么cout它呢？于是乎我们在定义加法的重载的时候就只能在前面加上a和b的类型了。
好，现在我没有类型了，void，怎么办？很简单，直接用 a + b;  因为它相当于：operator+(a,b);也就是调用一个函数，直接调用，没有返回值。
当然，结果也还是对的，各位可以看看…………

注意我想说的，学习计算机主要的是学习那个思想，而不是片面的记住语法或者其他，要想想为什么需要这样，这样我们的思维才会和计算机接近，才能更好的理解计算机，上面的这个例子就是很好的说明，这个函数很另类了吧，可是它完全符合各种语法，能够顺利运行。。
可是要记住的是，重载运算符为什么要重载，就是为了使用和内置类型一样的自然，如果像上面我定义的void那样，那么恐怕就很难懂了，如果将减号定义为加法的话，那么就更加的匪夷所思。也很难读了，违背了初衷，也就是一种错误的做法了，虽然理论上是可行的。。

计算机是一个很奇妙的东西，需要我们用心去体会……
                                                                                                                  ------------------------------<本章完>