GeezerVison

Ada

package Library_Interface is

   type Handle is limited private;

   -- Operations...

private
   type Hidden_Implementation;    -- Defined in the package body
   type Handle is access Hidden_Implementation;
end Library_Interface;

package body Library_Interface is

   type Hidden_Implementation is record
      ...    -- The actual implementation can be anything
   end record;

   -- Definition of the operations...

end Library_Interface;

C

#pragma once

typedef struct Integer Integer;

/*
 * The compiler considers struct Integer an incomplete type. Incomplete types
 * can be used in declarations.
 */

size_t integerSize();

void integerSetValue(Integer* i, int val);

int integerGetValue(Integer* i);

#include "Integer.h"

typedef struct Integer {
    int value;
} Integer;

/*
 * The caller will handle allocation.
 * Provide the required information only
 */

size_t integerSize() {
    return sizeof(Integer);
}

void integerSetValue(Integer* i, int val) {
    i->value = val;
}

int integerGetValue(Integer* i) {
    return i->value;
}

C++

export module wikipedia.examples:Foo;

import std;

using std::unique_ptr;

export namespace wikipedia::examples {

class Foo {
private:
    struct IntPair; // Not defined here
    unique_ptr<IntPair> ptr; // Opaque pointer
public:
    Foo(); // Constructor
    Foo(const Foo& other); // Copy constructor
    Foo(Foo&& other); // Move constructor
    Foo& operator=(const Foo& other); // Copy assignment operator
    Foo& operator=(Foo&& other); // Move assignment operator
    ~Foo(); // Destructor

    // Other operations...
};

}

module wikipedia.examples:Foo;

namespace wikipedia::examples {

struct Foo::IntPair {
    int a;
    int b;
};

Foo::Foo(): 
    ptr{std::make_unique<IntPair>()} {}

Foo::Foo(const Foo& other): 
    ptr{std::make_unique<IntPair>(*other.ptr)} {}

Foo::Foo(Foo&& other) = default;

Foo& Foo::operator=(const Foo& other) {
    *ptr = *other.ptr;
    return *this;
}

Foo& Foo::operator=(Foo&& other) = default;

Foo::~Foo() = default;

}