jasmine214--love

只有当你的内心总是充满快乐、美好的愿望和宁静时,你才能拥有强壮的体魄和明朗、快乐或者宁静的面容。
posts - 731, comments - 60, trackbacks - 0, articles - 0

从JAVA到C++的区别

Posted on 2010-07-30 12:57 幻海蓝梦 阅读(261) 评论(0)  编辑  收藏 所属分类: C++

原文:http://www.blogjava.net/RiKeR/articles/139269.html

一个完整的C++程序包括头文件(.h)和文本文件(.cpp).当 然两者都不是必须存在的.只要有其中之一就可以.

1.C++
使用#include预 处理器指示符来将头文件引入而成为我们程序的一部分.它将读入指定文件的内容,有两种格式
#include <some_file.h>
#include "my_file.h"
我们可以把用"<"">"引 入的头文件理解成是一个工程或者标准头文件(系统提供的).查找过程会检查预定义的目录.
而 用引号括起来则表明该文件是用户提供的头文件.查找将从当前文件目录开始.
这个include我 觉得类似于JAVAimport

2.
注 释方法一样

3.
类文件的定义.严格来说并没有类文件的说法.我 是为了和普通的cpp文件区分开来才这么说的.C++中类 的声明写在头文件中
声明一个类:

class test{
public:void test1();
private:void test2();
};



注意这里的写法.最后那个大括号后 面必须要跟一个分号的.JAVA则不用.我一开始及其不适应.
然 后在cpp文件中来定义

void test::test1(){
cout << "aaa";
}
void test::test2(){
cout << "bb";
}


注意:这里大括号后面有没有带分号都没关系.

4.C++
中 对函数的调用方法也灵活.

test t;
t.test2();
----------------
test* t = new test();
t->test2();


其实我还是喜欢test t = new test();t.test2()

5.
编译器的解析.如果没有引入头文件的话你必须把main()函 数放到文件的最下面.

void main(){
test();
}
void test(){
cout << "aa";
}



这样写编译器会报找不到test()方 法的.这个是C遗留下的问题.解决方法就是引入头文件,或 者把main写到最后.或者在main前面声明一下:

void test();
void main(){
test();
}
void test(){
cout << "aa";
}


这种做法就和引入头文件差不多了.

6.
析 构函数.这个特性很有用,在类消失的最后一刻自动调用这个种类型的函数来做一些清除操作

7.
争 议比较大的声明指针类型.
int* pt=0;
int *pt=0;
这个星号是紧跟着类型呢还是紧跟 着变量名呢.由于C++的灵活度太高.这两种写法都没错误.但 按理来说紧跟着类型应该会好一些.因为我们是在声明一个指针类型的变量.但如果按下面的写法:
int* pt,pt1;
你说pt1是指针类型吗,答案是不是.遇 到这种情况就要把*号紧跟着变量名了
int *pt,*pt1;

耐心点,接 下来的是精华

 

main 函 数
C++
//
自 由浮动 的函数
int main( int argc, char* argv[])
{
    printf( "Hello, world" );
}
Java
//
每个 函数(方法)都必须是一个类的一部分;java <class>运行是一个特定类的主函数会被调用
// (
因此你可以让每个类都有一个main函 数,这在写单元测试是很有用)
class HelloWorld
{
    public static void main(String args[])
    {
        System.out.println( "Hello, World" );
    }
}

 

类的声明
除 了 Java 不要求用分号外几乎是相同的。
C++
    class Bar {};
   
Java
    class Bar {}
   

方法声明
  
都 相同的, 除了在Java,方法必须总是某个类的一部分并且可能public/private/protected 作为修饰


构造函数和析构函数
构 造函数都是相同的 (即类的名字), Java没有准确意义上的的析构函数

静态成员函数和变量
方 法声明是相同的, Java 提供静态初始化块来来初始化静态变量 (不 需要在源文件中声明):
class Foo
{
    static private int x;
    //
静态初始化块
    { x = 5; }
}

对象的声明
C++
    //
在栈中
    myClass x;

 
    //
或者在堆中
    myClass *x = new myClass;

   
Java
   //
总 是在对堆中声明
    myClass x = new myClass();
   

 

  
C++
    class Foo : public Bar
    { ... };
   
Java
    class Foo extends Bar
    { ... }
   

访问级别 (abstraction barriers)
C++

   public:
        void foo();
        void bar();

   
Java
    public void foo();
    public void bar();
   

虚函数
C++
    virtual int foo(); //
或者非虚函数写作 int foo();
   
Java
    //
函数默认的就是虚函数; final关键字防止重载
    int foo(); //
或者, final int foo();

 

内存管理
大 体上是相同的--new 来分配, 但是 Java没有 delete, 因为它有垃圾回收器。

NULL vs null
C++
    //
初始化一个指针为 NULL
    int *x = NULL;
   
Java
   //
编译器将捕获使用未初始化的引用
   //
但是如果你因需要初始化一个引用而赋一个null,那么这是无效的
    myClass x = null;
   

布尔型
Java
有 一点罗嗦: 你必须写 boolean而不止是 bool.
C++
   bool foo;
Java

     boolean foo;

  
C++
    const int x = 7;
   
Java
    final int x = 7;
   

抛异常
首 先,Java在编译器强制抛异常如果你的方法可能会抛异常你必需明确报告
C++
     int foo() throw (IOException)
Java
     int foo() throws IOException

    
C++
    int x[10];
    //

    int *x = new x[10];
    //
使用 x,然后归还内存
    delete[] x;
   
Java
    int[] x = new int[10];
    //
使用 x, 内存有垃圾回收器回收或
    //
或 在程序生命周期尽头归还给系统
   

集合和迭代器
C++

迭 代器是类的成员。范围的开始是<容器>.begin(), 结束是 <容器>.end()。 用++ 操作符递增 *操作符访。 
    vector myVec;
    for ( vector<int>::iterator itr = myVec.begin();
          itr != myVec.end();
          ++itr )
    {
        cout << *itr;
    }

   
Java
迭代器只是一个 接口。 范围的开始是 <集合>.iterator,你必须用itr.hasNext()来 查看是否到达集合尾。 使用itr.next()(是在C++中使用操作符++ *操 作的结合)来获得下一个元素。 
    ArrayList myArrayList = new ArrayList();
    Iterator itr = myArrayList.iterator();
    while ( itr.hasNext() )
    {
        System.out.println( itr.next() );
    }
 
    //
, Java 5
    ArrayList myArrayList = new ArrayList();
    for( Object o : myArrayList ) {
        System.out.println( o );
    }
    
 

   
抽象类
C++
    //
只需要包含一个纯虚函数
    class Bar { public: virtual void foo() = 0; };
   
Java
    //
语法上 允许显示的声明!
    abstract class Bar { public abstract void foo(); }
 
    //
或者你也可以声明一个接口
    interface Bar { public void foo(); }
 
    //
然后让一个类继承这个接口:
    class Chocolate implements Bar
    {
        public void foo() { /* do something */ }
    }
   
引 用 vs  指针
C++
    //
引 用不可改变,通过使用指针来获得更多的灵活性
    int bar = 7, qux = 6;
    int& foo = bar;
   
Java
    //
引 用是可变的,仅存储对象地址;
    //
没有指针类型
    myClass x;
    x.foo(); // error, x is a null “pointer”
 
    //
注意你要总是用 . 来访问域
   
编 译
C++
    //
编译
    g++ foo.cc -o outfile
    //
运 行
    ./outfile
   
Java
   //
编译foo.java文件中的类成<classname>.class    javac foo.java
    //
通过调用<classname>中的静态main方 法来运行
    java <classname>
   
  
两种语言是一样的 (// /* */ 可以用)


只有注册用户登录后才能发表评论。


网站导航: