From Java to C 第二篇

From Java to C++ 第一篇

序言

上篇我们熟悉了C++的基本用法，既然C++也是一门面向对象的语言，那么这期我们就来对比下Java和C++中，方法和类是如何书写的。

方法

Java

public void hello() {
  System.out.print("Hello, World!");
}

C++

int hello(); // C++ 函数声明阶段
/**
 * 在main方法前，可先不声明，只有类中定义的函数才允许public修饰符
 */
void hello2(){
    cout << "Hello2, World!";
}
int main() {
    hello();
    hello2();
    return 0;
}
/**
 * 函数实现
 * 如果再main方法后实现，必须先声明
 * @return 
 */
int hello(){
    cout << "Hello, World!";
}

方法参数

Java

public void hello(String name){
  System.out.print("Hello, " + name + "!");
}

C++

void hello(string); // C++ 函数声明阶段
或者
void hello(string name); // 声明阶段可以带名字，可以不带
int main(){
    string aa;
    hello(aa);
}
void hello(string name){
    cout << "Hello, " + name + "!";
}

参数默认值

Java

public void hello(String name) {
  if (name == null) {
    name = "World";
  }

  System.out.print("Hello, " + name + "!");
}

C++

void hello(string = "World"); // 声明阶段，添加默认值World

int main() {
    hello();
    return 0;
}

/**
 * 函数实现
 * 如果再main方法后实现，必须先声明
 * @return
 */
void hello(string name) {
    cout << "Hello, " + name + "!";
}

方法Return

Java

public boolean hasItems() {
  return true;
}

C++

bool hasItems() {
    return true;
}

单表达式

Java

public double cube(double x) {
  return x * x * x;
}

C++

double cube(double x) {
    return x * x * x;
}

类->New

Java

File file = new File("file.txt"); //对象在堆中，对象引用在栈中

C++

class Test {
public:
    void add() {

    }
};

int main() {
    Test test1;  //栈中分配  ，由操作系统进行内存的分配和管理
    Test *test1;  //加*表示为指向Test类对像的指针变量，不加*则为Test类对像
    Test *test = new Test();  //堆中分配  ，由管理者进行内存的分配和管理，用完必须delete()，否则可能造成内存泄漏
    delete test;
    return 0;
}

注意：栈中内存的分配和管理由操作系统决定，而堆中内存的分配和管理由管理者决定

类->不可被继承

Java

public final class User {
}

C++

//C++11的新特性
class User final {
};

类->不可被继承的成员变量

Java

 class User {
     private final String name;

     public User(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }
 }

C++

class User {
private:
   const string u_name; // const限制只能被赋值一次
public:
    User(string name); // 声明
};

User::User(string name) : u_name(name){}; //实现

int main() {
    User user = User("test");
    return 0;
}

类-> 可选的构造参数

Java

final class User {
     private String name;
     private String lastName;

     public User(String name) {
         this(name, "");
     }

     public User(String name, String lastName) {
         this.name = name;
         this.lastName = lastName;
     }

     // And Getters & Setters
 }

C++

class User {
private:
     string u_name;
     string u_last_name;
public:
    User(string name,string lastName);
};

User::User(string name,string lastName = "1") : u_name(name) ,u_last_name(lastName){};

int main() {
    User user = User("test");
    User user1 = User("test","1");
    return 0;
}

抽象类

Java

public abstract class Document{
   public abstract int calculateSize();
}

public class Photo extends Document{
    @Override
    public int calculateSize() {

    }
}

C++

/**
 * 抽象类
 * 需要用纯虚函数
 * 纯虚函数是通过在声明中使用 "= 0" 来指定
 */
class Document{
public:
    virtual int calculateSize() = 0; //纯虚函数
};

class  Photo : Document{
public:
    int calculateSize() override{
        cout << "Photo";
        return 10;
    }
};

int main() {
    Photo photo;
    photo.calculateSize();
    return 0;
}

单例

Java

public class Document {
   private static final Document INSTANCE = new Document();

   public static Document getInstance(){
       return INSTANCE;
   }

 }

C++

//懒汉版

class Document {
private:
    static Document *document;
private:
    Document() {};
    ~Document() {};
    Document(const Document &);
    Document &operator=(const Document &);

private:
    class Deletor {
    public:
        ~Deletor() {
            if(Document::document != NULL)
                delete Document::document;
        }
    };
    static Deletor deletor;

public:
    static Document *getInstance() {
        if (document == NULL) {
            document = new Document();
        }
        return document;
    }
};

在程序运行结束时，系统会调用静态成员deletor的析构函数，该析构函数会删除单例的唯一实例。使用这种方法释放单例对象有以下特征：

• 在单例类内部定义专有的嵌套类。
• 在单例类内定义私有的专门用于释放的静态成员。
• 利用程序在结束时析构全局变量的特性，选择最终的释放时机。

枚举类

Java

enum Color 
{ 
    RED, BLUE, WHITE, BLACK}; 
}

C++

enum Color {RED, BLUE, WHITE, BLACK}; // 定义枚举类型Color
enum fruit_set {apple, orange, banana=1, peach, grape}
//枚举常量apple=0,orange=1, banana=1,peach=2,grape=3。

编译系统为每个枚举常量指定一个整数值，默认状态下，这个整数就是所列举元素的序号，序号从0开始。 可以在定义枚举类型时为部分或全部枚举常量指定整数值，在指定值之前的枚举常量仍按默认方式取值，而指定值之后的枚举常量按依次加1的原则取值。

总结一下

本期，我对比了函数，类，抽象类，单例，枚举等，整体上大同小异，你可能也注意到了一些细节的不同，其实大多时候都是很小的细节决定了问题的产生，虽然我可以通过这两篇的文章快速的了解C++，但还是不够，需要更深入的研究和学习，下期我们就针对某些细节以及一些概念的理解，来完成C++的从入门到精通。加油。