一、面向过程设计中的static

1、静态全局变量

在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：

//Example 1
#include <iostream.h>
void fn();
static int n; //定义静态全局变量
void main()
{
n=20;
cout<<n<<endl;
fn();
}
void fn()
{
n++;
cout<<n<<endl;
}

• 该变量在全局数据区分配内存；
• 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；
• 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；　

　　一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将

	static int n; //定义静态全局变量

	int n; //定义全局变量

• 静态全局变量不能被其它文件所用；
• 其它文件中可以定义相同名字的变量，不会发生冲突；

您可以将上述示例代码改为如下：

//Example 2
//File1
#include <iostream.h>
void fn();
static int n; //定义静态全局变量
void main()
{
n=20;
cout<<n<<endl;
fn();
}
//File2
#include <iostream.h>
extern int n;
void fn()
{
n++;
cout<<n<<endl;
}

static int n; //定义静态全局变量

int n; //定义全局变量

2、静态局部变量

在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。

我们先举一个静态局部变量的例子，如下：

//Example 3
#include <iostream.h>
void fn();
void main()
{
fn();
fn();
fn();
}
void fn()
{
static n=10;
cout<<n<<endl;
n++;
}

静态局部变量有以下特点：

• 该变量在全局数据区分配内存；
• 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
• 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；
• 它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

3、静态函数

　　在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

静态函数的例子：

//Example 4
#include <iostream.h>
static void fn();//声明静态函数
void main()
{
fn();
}
void fn()//定义静态函数
{
int n=10;
cout<<n<<endl;
}

• 静态函数不能被其它文件所用；
• 其它文件中可以定义相同名字的函数，不会发生冲突；

二、面向对象的static关键字（类中的static关键字）

1、静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

//Example 5
#include <iostream.h>
class Myclass
{
public:
Myclass(int a,int b,int c);
void GetSum();
private:
int a,b,c;
static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员
Myclass::Myclass(int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c;
}
void Myclass::GetSum()
{
cout<<"Sum="<<Sum<<endl;
}
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
M.GetSum();
}

• 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
• 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；
• 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
• 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
• 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
  ＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
• 类的静态数据成员有两种访问形式：
  ＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
  如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；
• 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
• 同全局变量相比，使用静态数据成员有两个优势：

1. 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
2. 可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；
   

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

//Example 6
#include <iostream.h>
class Myclass
{
public:
Myclass(int a,int b,int c);
static void GetSum();/声明静态成员函数
private:
int a,b,c;
static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员
Myclass::Myclass(int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}
void Myclass::GetSum() //静态成员函数的实现
{
//	cout<<a<<endl; //错误代码，a是非静态数据成员
cout<<"Sum="<<Sum<<endl;
}
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
Myclass::GetSum();
}

• 出现在类体外的函数定义不能指定关键字static；
• 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
• 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
• 静态成员函数不能访问非静态成员函数和非静态数据成员；
• 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
• 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
  ＜类名＞::＜静态成员函数名＞（＜参数表＞）
  调用类的静态成员函数。

1,表示变量是静态存储变量
表示变量存放在静态存储区.
2,表示该变量是内部连接
(这种情况是指该变量不在任何{}之内,就象全局变量那样,这时候加上static)
,也就是说在其它的.cpp文件中,该变量是不可见的(你不能用).

当static加在函数前面的时候
表示该函数是内部连接,之在本文件中有效,别的文件中不能应用该函数.
不加static的函数默认为是全局的.
也就是说在其他的.cpp中只要申明一下这个函数,就可以使用它.

1、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？
    答：全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。
    从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。
    static函数与普通函数作用域不同。static函数仅在本文件中使用。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件
    static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
    static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
    static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

2、如何引用一个已经定义过的全局变量？
     答：extern
     可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间 会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？
    答：可以，在不同的C文件中以static形式来声明同名全局变量。
    可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错。

函数TheFunction()的返回值被赋值给对SimpleCat类的一个引用,然后使用这个引用来获得对象的成员变量age的值
为了证明函数TheFunction()在自由存储区中创建的对象被赋给了函数main()声明的引用，对rCat采取取址运算，很明显，它显示了其引用的对象的地址，并且和自由存储区中的对象的地址相匹配。
这一切看上去都很正确，但是如何释放被占用的内存，对于引用是不能使用delete运算符的，一个笔记聪明的方法是声明另一个指针，并使用由rCat得到的地址对它进行初始化。这样做确实可以释放内存，避免了内存的泄漏，但是存在一个小问题，在delete pCat后，rCat引用又代表什么呢？？引用必须是一个实际对象的别名；如果引用一个空对象的话（现在就是这种情况）那么程序就是无效的。。

注意：不能过分去强调一个使用对空对象的引用的程序，也行能通过编译，但是即使程序通过了编译，它仍然是病态的，而且执行结果也是不可预料的

关于这个问题，存在这3种解决方案
第1种是在第49行声明一个SimpleCat类对象，然后从函数TheFunction()中采取值传递的方式返回它的局部对象，这时不能在自由存储区来分配对象空间，不能使用new，
第2种是在函数TheFunction()中声明一个位于自由存储区中的SimpleCat类的对象，但是让函数返回一个指向内存区域的指针，然后完成对对象的操作，调用函数可以删除这个指针
第3种可行的方案，也是正确的，是在调用函数中声明对象，然后通过引用的方式把它传递给函数TheFunction()

 Person.java

class Person
{
 public String name = "not know";//4
 public int age = -1 ;//5
 public Person()
 {    
 }
 public Person(String name , int age)//3
 {
  this.name = name ;//6
  this.age = age;//7
 }
 public void showInfo()
 {
  System.out.println("Name is :"+name+" Age is :"+age);
 }
}
class Student extends Person
{
 public String school = "not konwn";//8
    public Student()
    {
     super();    
    }
    public Student (String name ,int age, String school)  //1
    {
     super(name,age);  //2
     this.school = school;//9
    }
    public void showInfo()
    {
     super.showInfo();
     System.out.println("School is :"+school);
    }
}

AllTest.java

class AllTest
{
 public static void main(String[]args)
 {
  Student stA = new Student("wanghao",20,"qinghuadaxue"); //0
 }
}

其语句的执行顺序是怎样的呢？
java中，在使用new操作符创建一个类的实例对象的时候，开始分配空间并将成员变量初始化为默认的数值，注意这里并不是指将变量初始化为在变量定义处的初始值，而是给整形赋值0，给字符串赋值null 这一点于C++不同，（student.name = null , student.age = 0 ）
然后在进入类的构造函数。

在构造函数里面，首先要检查是否有this或者super调用，this调用是完成本类本身的构造函数之间的调用，super调用是完成对父类的调用。二者只能出现一个，并且只能作为构造函数的第一句出现。在调用this和super的时候实现程序的跳转，转而执行被调用的this构造函数或者super构造函数。
在this和super执行完毕，程序转而执行在类定义的时候进行的变量初始化工作。
这个执行完毕，才是构造函数中剩下的代码的执行。
执行顺序已经用绿色标出。

Order of initialization
Within a class, the order of initialization is determined by the order that the variables are defined within the class. The variable definitions may be scattered throughout and in between method definitions, but the variables are initialized before any methods can be called—even the constructor. For example: Feedback
//: c04:OrderOfInitialization.java
// Demonstrates initialization order.
import com.bruceeckel.simpletest.*;

// When the constructor is called to create a
// Tag object, you'll see a message:
class Tag {
  Tag(int marker) {
    System.out.println("Tag(" + marker + ")");
  }
}

class Card {
  Tag t1 = new Tag(1); // Before constructor
  Card() {
    // Indicate we're in the constructor:
    System.out.println("Card()");
    t3 = new Tag(33); // Reinitialize t3
  }
  Tag t2 = new Tag(2); // After constructor
  void f() {
    System.out.println("f()");
  }
  Tag t3 = new Tag(3); // At end
}

public class OrderOfInitialization {
  static Test monitor = new Test();
  public static void main(String[] args) {
    Card t = new Card();
    t.f(); // Shows that construction is done
    monitor.expect(new String[] {
      "Tag(1)",
      "Tag(2)",
      "Tag(3)",
      "Card()",
      "Tag(33)",
      "f()"
    });
  }
} ///:~

//: c04:StaticInitialization.java
// Specifying initial values in a class definition.
class Bowl {
  Bowl(int marker) {
    System.out.println("Bowl(" + marker + ")");
  }
  void f(int marker) {
    System.out.println("f(" + marker + ")");
  }
}

class Table {
  static Bowl b1 = new Bowl(1);
  Table() {
    System.out.println("Table()");
    b2.f(1);
  }
  void f2(int marker) {
    System.out.println("f2(" + marker + ")");
  }
  static Bowl b2 = new Bowl(2);
}

class Cupboard {
  Bowl b3 = new Bowl(3);
  static Bowl b4 = new Bowl(4);
  Cupboard() {
    System.out.println("Cupboard()");
    b4.f(2);
  }
  void f3(int marker) {
    System.out.println("f3(" + marker + ")");
  }
  static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
  static Test monitor = new Test();
  public static void main(String[] args) {
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    t2.f2(1);
    t3.f3(1);
    monitor.expect(new String[] {
      "Bowl(1)",
      "Bowl(2)",
      "Table()",
      "f(1)",
      "Bowl(4)",
      "Bowl(5)",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "Creating new Cupboard() in main",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "Creating new Cupboard() in main",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "f2(1)",
      "f3(1)"
    });
  }
  static Table t2 = new Table();
  static Cupboard t3 = new Cupboard();
} ///:~

继承情况下的初始化
了解一下包括继承在内的初始化的过程将是非常有益的，这样就能有个总
体的了解。看看下面这段代码：
//: c06:Beetle.java
// The full process of initialization.
class Insect {
  protected static Test monitor = new Test();
  private int i = 9;
  protected int j;
  Insect() {
    System.out.println("i = " + i + ", j = " + j);
    j = 39;
  }
  private static int x1 = print("static Insect.x1 initialized");
  static int print(String s) {
    System.out.println(s);
    return 47;
  }
}

public class Beetle extends Insect {
  private int k = print("Beetle.k initialized");
  public Beetle() {
    System.out.println("k = " + k);
    System.out.println("j = " + j);
  }
  private static int x2 = print("static Beetle.x2 initialized");
  public static void main(String[] args) {
    System.out.println("Beetle constructor");
    Beetle b = new Beetle();
    monitor.expect(new String[] {
      "static Insect.x1 initialized",
      "static Beetle.x2 initialized",
      "Beetle constructor",
      "i = 9, j = 0",
      "Beetle.k initialized",
      "k = 47",
      "j = 39"
    });
  }
} ///:~

当你用Java 运行Beetle 的时候，第一件事就是访问了Beetel.main( )(这是一个static 方法)，于是装载器(loader)就会为

你寻找经编译的Beetle 类的代码(也就是Beetle.class 文件)。在装载的过程中，装载器注意到它有一个基类(也就是extends 所要表示的意思)，于是它再装载基类。不管你创不创建基类对象，这个过程总会发生。(试试看，把创建对象的那句注释掉，看看会有什么结果。)如果基类还有基类，那么这第二个基类也会被装载，以此类推。下一步，它会执行“根基类(root bas e class)”(这里就是Insect)的static 初始化，然后是下一个派生类的static 初始化，以此类推。这个顺序非常重要，因为派生类的“静态初始化(即前面讲的static 初始化)”有可能要依赖基类成员的正确初始化。

现在所有必要的类都已经装载结束，可以创建对象了。首先，对象里的所有的primitive 都会被设成它们的缺省值，而reference 也会被设成null——这个过程是一瞬间完成的，对象的内存会被统一地设置成“两进制的零(binary zero)”。如果有对成员变量赋初值，则对成员变量进行赋值，然后调用基类的构造函数。调用是自动发生的，但是你可以使用super 来指定调用哪个构造函数(也就Beetle( )构造函数所做的第一件事)。基类的构造过程以及构造顺序，同派生类的相同。基类构造函数运行完毕之后，会按照各个变量的字面顺序进行初始化。最后会执行构造函数的其余部分。

没有问题，它返回的是一个值，而不是引用，所以是正确的。在item1 = item2 + item3 中发生了一次值拷贝(赋值)，也就是将item2+item3返回的局部变量拷贝给了item1之后，局部变量的作用域结束 
 
可以返回局部变量，但是不能返回局部变量的引用。理解区分值和引用这两个概念是学习C++的一大关键，明白这两个概念之后，你就会理解为什么C++的类里面需要有拷贝构造函数，赋值操作符，析构函数三个元素了以及其它的一些稀里古怪的用法和忠告了
--

Sales_item operator+(const Sales_item& lhs,const Sales_item& rhs) 
{ 
    Sales_item ret(lhs) ; 
    ret+= rhs ; 
    return ret ; 
}
在return ret 时并不是简单的返回这个局部变量，而是返回的是ret的一个副本temp,
temp是通过拷贝构造函数实现的 即 Sales_item temp(ret);也就是说在主函数中用的其实是个temp,而ret早在operator+调用完毕后就释放了，而temp这个 对象一直在主函数中贮存（虽然显示是看不到的 ）  ????

嗯嗯，临时对象一直是个有争议的话题。temp只是临时构造的，在赋值完毕之后它就析构了，不是一直在主函数中贮存的。这个临时对象的作用域是什么？？？
在你提的这种情况下，其实编译器是可以优化掉这个副本的，但是可惜C++标准只允许优化  “Sales_item item1=item2+item3” 这种情况的,也就是在拷贝构造这种情况下，编译器都不再产生副本，而赋值还是不行的。也许在未来的C++标准由可能通过拓展语义来消除临时对象，毕竟临时对象成为影响C++效率的一个主要因素。
--

???
目前的C++标准不允许在赋值的时候优化掉函数返回的副本，也就是下面这两种情况是不一样的
 
//这是赋值给item1，目前的标准下是会产生副本 temp
Sales_item item1,item2,item3;
item1=item2+item3;
 
//这是拷贝构造item1，编译器通常会优化(这个优化区别下面所说的NRV优化)掉副本，也就是不产生副本 temp
Sales_item item2,item3;
Sales_item item1=item2+item3;

看一下代码中的TheFunctionTwo();

14th August 2007, 11:40 pm

原作：Cay Horstmann 英文原文

翻译：Aqua  prglab.com

注：很多程序员包括本人在内都是先学会的Java，然后才学的C++，其实C++与Java有很多相似和互通之处，有相当的Java知识可以对应转化到C++概念，从而帮助我们快速上手。这篇文章介绍的内容就对从Java向C++转变很有帮助，所以翻译推荐给有同样需要的朋友。翻译中加入了本人的理解，不完全是全文照搬。有不明或异议，请参考原文，或留言讨论。还是那句话，推荐多读原版资料。

学习怎样从一种编程语言转移到另一种编程语言是今日的程序员必须面对的现实，还好，C++和Java有很多共同的特点，所以从Java转到C++就容易许多。C++比Java复杂很多，本文并没打算涵盖所有C++的功能。但是如果你能够熟练掌握本文中的所有知识点，也足够有效的使用C++了。

这里我们只讲Java与C++的不同之处。像流程控制(if, while, for)这些在C++与Java中完全一样的内容这里就不讲了。

本文是基于ANSI C++标准的，一些老的C++ 编译器可能不支持这里讲到的一些重要功能。要使用这些编译器，你需要更多学习C++中从C继承来的部分。那些都超出了本文的范畴，也就不介绍了。

1. 数据类型和变量

C++ 中的变量类型与Java很相似。像Java一样，C++ 有int和 double类型。但是这些数字类型的取值范围是依赖于机器的。比如在16位系统上，例如运行DOS 或Windows 3.x的PC机上，int是双字节(2-byte)的，取值范围比Java的4-byte的int要小很多。在这些机器上，如果 int 不够用的话，你需要使用长整型long。

C++ 有 short和 unsigned类型来更有效的存储数字。（我认为所谓有效是指更高的空间利用率。） 最好是尽量避免使用这些类型除非是空间利用的有效性对你的系统真的非常重要。

在C++中布尔型用 bool表示，而不像在Java中用boolean。

C++ 中字符串类型用 string表示。它与Java中的 String类型非常相似，但是，还是要逐一以下几点不同之处：

1. C++ 字符串存储ASCII 码字符，而不是标准码Unicode 字符

2. C++ 字符串是可以被修改的，而Java字符串的内容是不可修改的(immutable)。

3. 取子字符串的操作在 C++ 中叫做 substr，这个命令s.substr(i, n)从字符串s中取得从位置 i 开始长度为n的子字符串。

4. 在C++中，你只能够将字符串与其它字符串对象相串联(concatenate)，而不能够与任意的对象相串联。

5. C++中可以直接使用关系操作符 ==、 !=、 <、 <=、 >、 >= 来进行字符串比较，其中后面四个操作符是按字母顺序进行比较的。这比Java中使用函数equals和compareTo来比较要方便很多。

2. 变量和常量

在C++中，本地变量的定义看起来与Java中相同，例如：

int n = 5;

实际上这正是C++和Java的一个重要不同之处。C++编译器不对本地变量进行初始化检验，所以在C++中很容易忘记初始化一个变量，这种情况下，变量的值该变量所占内存区域中刚好当前存在随机值。这显然是很容易产生程序出错的地方。

与Java一样， C++中类可以有数据域和静态变量。不同的是，C++中变量可以在函数甚至是类的外面定义，这些所谓的全局变量可以在程序的任何函数中被访问，因而不易被很好的管理。所C++中应该尽量避免使用全局变量。

在C++中，常量可以在任何地方被定义（记得在Java中，常量必须是类的静态数据static data)。 C++ 使用关键字 const来定义常量，而Java中是 final。例如：

const int DAYS_PER_YEAR = 365;

3. 类

C++ 中对类的定义与Java有些不同，这里是一个例子：一个C++ 版本的 Point类:

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;

};

这里几点重要的不同是：

1. C++的类定义中分为公共和私有部分，分别以关键字 public和 private开始。而在Java中，每一个元素都必须标明 public或 private。

2. C++中类的定义只包含函数的声明，真正的实现另外单独列出。

3. 访问函数(accessor methods)标有关键字 const，表明这个函数不会改变本对象的元素值。

4. 类定义的结尾处有分号

类中函数的实现跟在类的定义之后。因为函数是在类外面定义的，所以每一个函数的名字前面要加类名称作为前缀，并使用操作符双冒号::来分割类的名称和函数的名称。不改变隐含参数值（即当前对象的值）的访问函数用 const标明。如下所示是上面类定义中的函数的实现：

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的，只需要在变量的名字后面直接赋予构造函数的参数就可以了，例如：

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

如果不跟参数赋值，则使用默认构造函数，例如：

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

这一点与Java很不同。在Java中，这个命令仅仅生成一个没有初始化的对象reference，要创建对象还得使用new在堆中创建一个实际的对象.  

而在C++中，它生成一个实际的对象。

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

Point q = p; /* 拷贝p到q ,q是另外一个新的对象，有自己的内存空间*/

q.move(1, 1); /* 移动q而p不动，即q的值变了，而p的不变*/

多数情况下，C++中这种对象直接对值操作的特性使用起来很方便，但是也有些时候不尽如人意：

C++中对象的指针非常类似于Java中的引用

1. 当需要一个函数中修改一个对象的值，必须记住要使用按引用调用call by reference (参见下面函数部分)，或者将参数定义为指针类型,在函数中通过指针来操作其实际指向的对象

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

3. 一个对象变量只能存储一种特定的类型的值，如果你想要使用一个变量来存储不同子类的对象的值（多态ploymorphism)，则需要使用指针。

4. 如果你想在C++中使用一个变量来或者指向null或者指向一个实际的对象，则需要使用指针

5. 函数

在Java中，每一个函数必须或者是对象函数(instance method)，或者是静态函数(static function)或称类函数。C++同样支持对象函数和静态函数（类函数），但同时C++也允许定义不属于任何类的函数，这些函数叫做全局函数（global functions）。

特别的是，每一个C++ 程序都从一个叫做 main的全局函数开始执行：

int main()

{ . . .

}

还有另外一个格式的main函数可以用来捕捉命令行参数，类似于Java的main函数，但是它要求关于C格式的数组和字符串的知识，这里就不介绍了。

按照习惯，通常如果程序执行成功， main函数返回0，否则返回非零整数。

同Java一样，函数参数是通过值传递的(passed by value)。在Java中，函数无论如何都是可以修改对象(类对象)的值的（因为java中传递的是java中的引用,相当与C++中的指针。Java函数返回时也是返回的引用,将此引用拷贝到外面的某个引用变量中）。然而在C++中，因为对象直接存储的是实际的值，而不是指向值的reference，也就是说传入函数的是一个实际值的拷贝，因此也就无法修改原来对象的值。(C++中函数返回时也是要拷贝到外面的变量中的,是指针就拷贝指针，是对象就进行对象的拷贝)

所以，C++ 有两种参数传递机制，同Java一样的按值调用(call by value) ，以及按地址调用(call by reference)。当一个参数是按reference传递时，函数可以修改其原始值。Call by reference 的参数前面有一个地址号 &跟在参数类型的后面，例如：

void raiseSalary(Employee& e, double by)

{ . . .

}

下面是一个典型的利用call by reference的函数，在Java中是无法实现这样的功能的。

void swap(int& a, int& b)

{ int temp = a;

a = b;

b = temp;

}

如果使用 swap(x, y)来调用这个函数，则reference参数 a和 b指向原实际参数x和 y的位置，而不是它们的值的拷贝，因此这个函数可以实现实际交换这两个参数的值。

在 C++中，每当需要实现修改原参数的值时你就可以使用按地址调用 call by reference 。

6. 向量Vector

C++ 的向量结构结合了Java中数组和向量两者的优点。一个C++ 的向量可以方便的被访问，其容量又可以动态的增长。如果 T是任意类型，则 vector<T>是一个元素为 T类型的动态数组。下面的语句

vector<int> a;

产生一个初始为空的向量。而语句

vector<int> a(100);

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

a.push_back(n);

调用 a.pop_back()从a中取出最后一个元素（操作后这个元素被从a中删掉)， 使用函数size可以得到当前a中的元素个数。

你还可以通过我们熟悉的 []操作符来访问向量中元素，例如：

for (i = 0; i < a.size(); i++) {

sum = sum + a[i];

}

同Java中一样，数组索引必须为 0 和a.size() - 1之间的值。但是与Java不同的是，C++中没有runtime的索引号合法性检验。试图访问非法的索引位置可能造成非常严重的出错。

就像所有其它 C++ 对象一样，向量也是值。如果你将一个向量赋值给另外一个向量变量，所有的元素都会被拷贝过去。

vector<int> b = a; /* 所有的元素都被拷贝了 */

对比Java中的情况，在Java中，一个数组变量是一个指向数组的reference。拷贝这个变量仅仅产生另外一个指向同一数组的reference，而不会拷贝每一个元素的值。

正因如此，如果一个C++函数要实现修改向量的值，必须使用reference参数：

void sort(vector<int>& a)

{ . . .

}

7. 输入和输出

在C++中，标准的输入输出流用对象 cin和 cout表示。我们使用 <<操作符写输出，例如：

cout << “Hello, World!”;

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

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

我们使用 >>操作符来读入一个数字或单词，例如：

double x;

cout << “Please enter x: “;

cin >> x;

string fname;

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

cin >> fname;

函数getline可以读入整行的输入，例如：

string inputLine;

getline(cin, inputLine);

如果到达输入的结尾，或者一个数字无法被正确的读入，这个流对象会被设置为 failed 状态，我们可以使用函数 fail来检验这个状态，例如：

int n;

cin >> n;

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

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

8. 指针pointer

我们已经知道在C++中，对象变量直接存储的是对象的值。这是与Java不同的，在Java中对象变量存储的是一个地址，该地址指向对象值实际存储的地方。有时在C++中也需要实现这样的布置，这就用到了指针pointer。在 C++中，一个指向对象的变量叫做指针。如果T是一种数据类型，则 T*是指向这种数据类型的指针。

就像 Java中一样，一个指针变量可以被初始化为空值 NULL，另外一个指针变量的值，或者一个调用new生成的新对象：

Employee* p = NULL;

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

Employee* r = q;

实际上在C++中还有第四种可能，那就是指针可以被初始化为另外一个对象的地址，这需要使用地址操作符 &：

Employee boss(”Morris, Melinda”, 83000);

Employee* s = &boss;

这实际上并不是什么好主意。保险的做法还是应该直接让指针指向使用 new生成的新对象。

到目前为止，C++ 指针看起来非常像 Java 的对象引用变量。然而，这里有一个很重要的语法的不同。我们必须使用星号操作符 *来访问指针指向的对象。如果 p是一个指向Employee对象的指针，则 *p才代表了这个对象：

Employee* p = . . .;

Employee boss = *p;

当我们需要执行对象的函数或访问对象的一个数据域时，也需要使用 *p：

(*p).setSalary(91000);

*p外面的括号是必需的，因为 .操作符比 * 操作符有更高的优先级。C的设计者觉得这种写法很难看，所以他们提供了另外一种替代的写法，使用 -> 操作符来实现 *和 .操作符的组合功能。表达式

p->setSalary(91000);

可以调用对象*p的函数 setSalary。你可以简单的记住.操作符是在对象上使用的，-> 操作符是在指针上使用的。

如果你不初始化一个指针，或者如果一个指针为空值 NULL 或指向的对象不再存在，则在它上面使用 *或 ->操作符就会出错。 不幸的是 C++ runtime 系统并不检查这个出错。如果你范了这个错误，你的程序可能会行为古怪或死机。

而在Java中，这些错误是不会发生的。所有的reference都必须初始化，所有的对象只要仍有reference指向它就不会被从内存中清除，因此你也不会有一个指向已被删除的对象的reference。Java的runtime 系统会检查reference是否为空，并在遇到空指针时抛出一个null pointer的例外(exception)。

C++ 和 Java还有一个显著的不同，就是 Java 有垃圾回收功能，能够自动回收被废弃的对象。而在C++中，需要程序员自己管理内存分配回收。

C++中当对象变量超出范围时可以自动被回收。但是使用new生成的对象必须用delete操作符手动删除，例如：

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

. . .

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

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

9. 继承

C++和Java中继承的基本语法是很相似的。在C++中，使用 : public代替Java中的extends来表示继承关系 。 (C++ 也支持私有继承的概念，但是不太有用。)

默认情况下，C++中的函数不是动态绑定的。如果你需要某个函数实现动态绑定，需要使用virtual声明它为虚函数，例如：

class Manager : public Employee

{

public:

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

virtual void print() const;

private:

string department;

};

同Java一样，构造函数中调用父类的构造函数有特殊的语法。 Java使用关键字 super。C++中必须在子类的构造函数体外调用父类的构造函数。下面是一个例子：

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

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

{ department = dept;

}

Java 中在子类函数中调用父类的函数时也使用关键字 super。而在C++中是使用父类的名称加上操作符 ::表示，例如：

void Manager::print() const

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

cout << department << “"n”;

}

一个 C++ 对象变量只能存储特定类型的对象值。要想在C++中实现多态(polymorphism)，必须使用指针。一个 T*指针可以指向类型为 T或 T的任意子类的对象，例如：

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

你可以将父类和不同子类的对象混合收集到一个元素均为指针的向量中，然后调用动态绑定的函数，如下所示：

vector<Employee*> staff;

. . .

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

staff[i]->print();