C++是否有interface class？与Java的差异及C++接口类编写方法

Great question! Let's break this down clearly, since the concept of interfaces works a bit differently between C++ and Java.

Short answer: C++ doesn't have a native interface keyword like Java does, but we absolutely simulate interface-like behavior using abstract classes with pure virtual functions. This is a standard, widely accepted practice in C++ development to achieve the same decoupling and abstraction goals as Java interfaces.

Let's run through the most important distinctions:

• Syntax & Keywords: Java has a dedicated interface keyword, and classes "implement" interfaces using implements. In C++, we use abstract classes (with all pure virtual functions) and inherit them using public inheritance—there's no separate syntax for "implementing" vs "inheriting".
• Multiple Inheritance: Java classes can only extend one parent class, but implement multiple interfaces. C++ allows a class to inherit from multiple abstract (interface-style) classes directly—no restrictions here, since pure virtual classes don't introduce the classic diamond problem risks (as long as you avoid adding member variables).
• Default Methods: Java 8+ lets interfaces have default methods with concrete implementations that subclasses can use without overriding. In C++, you can provide a default implementation for a pure virtual function, but there's a catch: subclasses still must override the pure virtual function—they just have the option to call the base class's implementation from their own override.
• Member Variables: Java interfaces can only contain public static final constants. C++ interface-style classes can have member variables (though this is strongly discouraged, as it breaks the interface's purpose of defining behavior only), whereas best practice is to keep them empty except for pure virtual functions and a virtual destructor.

The core idea is to create an abstract class that contains only pure virtual functions (plus a virtual destructor). Here's a concrete example matching common design pattern use cases:

// This acts exactly like a Java interface
class Shape {
public:
    // Virtual destructor is non-negotiable!
    // Without it, deleting a subclass object via a Shape* pointer will leak memory
    virtual ~Shape() = default;

    // Pure virtual functions = "interface methods" that subclasses MUST implement
    virtual double calculateArea() const = 0;
    virtual double calculatePerimeter() const = 0;
};

// A subclass "implementing" the interface
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    // Use `override` to catch typos/parameter mismatches (C++11+)
    double calculateArea() const override {
        return 3.14159 * radius * radius;
    }

    double calculatePerimeter() const override {
        return 2 * 3.14159 * radius;
    }
};

Critical notes for C++ interfaces: #

1. Always add a virtual destructor: As mentioned, this prevents memory leaks when dealing with polymorphic objects. Using = default makes this clean and efficient.
2. Use override for clarity: This keyword ensures you're actually overriding a base class method—if you misspell the function name or get parameters wrong, the compiler will throw an error.
3. Avoid member variables: Stick to pure virtual functions only to keep the interface focused on behavior, just like Java interfaces.
4. Optional: Pure virtual functions with default implementations: If you want something close to Java's default methods, you can do this (though semantics differ):

   class Shape {
   public:
       virtual ~Shape() = default;
       virtual double calculateArea() const = 0;
       virtual double calculatePerimeter() const = 0;
   
       // Pure virtual function with a default implementation
       virtual void printDetails() const = 0;
   };
   
   // Define the default implementation outside the class
   void Shape::printDetails() const {
       std::cout << "Area: " << calculateArea() << ", Perimeter: " << calculatePerimeter() << "\n";
   }
   
   class Circle : public Shape {
       // ... member variables and other methods ...
       void printDetails() const override {
           // Call the base class's default implementation
           Shape::printDetails();
           std::cout << "Shape type: Circle\n";
       }
   };
   

   Remember: Subclasses still have to override printDetails()—they can't just use the default directly like in Java.

内容的提问来源于stack exchange，提问作者R June