C ++抽象类

Question

I am new to C++, I coded in Java for an year. The equivalent in C++ for interfaces and abstract classes alike is only abstract classes. Is that supposed to be a handicap while doing factory design? There are many times I want to leave out the defining the methods to the inheriting classes and I want to enforce that.

Answer 1

If you define like this you can have what you want:

class A {
  public:
    virtual void pure_virtual(int param1) = 0;
    virtual ~A() { };
}; 

EDIT : Thanks Nikolai and Mike!

Answer 2

Java interfaces are best translated as C++ abstract classes. In Java (as far as I know) a interface is merely a subset of an abstract class anyway, except it allows "multiple inheritance" which C++ has in all cases anyway.

class thing_interface {
public:
    virtual ~thing_interface() {}
    virtual void foo() =0; //pure virtual function
};
class other_interface {
public:
    virtual ~other_interface () {}
    virtual void bar() =0; //pure virtual function
};

class thing_impl : public thing_interface, public other_interface { 
protected:
    int member;
public:
    thing_impl() : member(0) {}
    virtual ~thing_impl() {};
    virtual void foo() { std::cout << "FOO!\n";}
    virtual void bar() { std::cout << "BAR!\n";}
};

The =0 syntax means it is not defined in the interface, but must be defined in classes that fulfill the interface. Also note that if you have any virtual function, you almost always want a virtual destructor as well. C++ will tell you an error if you try to make a thing_interface by itself, since there's no implementation functions.

It's not really a handicap, since I can't think of anything Java can do here that C++ can't.

Answer 3

In terms of interface/abstract classes you wont feel handicap. You should read about C++ pure virtual functions and abstract classes.

To have interface in C++, here is the sudo code:

class MyInterface {
  virtual void func1() = 0;
  virtual int func2(int x, int y) = 0;
}


class MyAnotherInterface {
  virtual void func3() = 0;
  virtual int func4(int x, int y) = 0;
}

To have abstract class in C++, here is the sudo code. You can see it only implements one function from the interface above. So you cannot create instance of it.

class MyAbstract : public MyIterface {
  void func1() {
    printf("in func1");
  }
}

Now the actual concrete class:

class MyConcreteClass : public MyAbstract, public MyAnotherIterface {
  int func2(int x, int y) {
    printf("func2 x=%x,y=%y",x,y);
  }

  void func3() {
    printf("in func3");
  }

  int func4(int x, int y) {
    printf("func4 x=%x,y=%y",x,y);
  }
}

There are some issues when you are using Multiple inheritance as I am using for MyConcreteClass. But if you only have one base with member variables and other base classes contain only pure virtual functions then this pattern acts exactly like Java, where the class containing some methods and member variables maps to extends and other classes which contain only pure virtual functions maps to `implements'.

In our example, Java equivalent code is

class MyConcreteClass extends MyAbstract implements MyAnotherInterface {
  public int func2(int x, int y) {
    System.out.print(String.format("func2 x=%x,y=%y",x,y));
  }

  public void func3() {
    System.out.print("in func3");
  }

  public int func4(int x, int y) {
    System.out.print(String.format("func4 x=%x,y=%y",x,y));
  }    
}

Where you feed handicap

The only other place where I feel handicap when coming from Java is generics. C++ has templates for that, but they some serious limitations.