Differentiate interface abstraction from const member function about proxy HOT 3 CLOSED

Thank you for the suggestion @coyorkdow. Actually, proxy already has the capability to differentiate const and non-const expressions, but in a different form from traditional (inheritance-based) polymorphism. Specifically, traditional one requires const on the base type while using it (client shall have the knowledge of const-ness to use a polymorphic object correctly), while proxy only requires const when constructing it (client no longer needs this information anymore, making the API boundary clean).

For example:

#include <cstdio>
#include <memory>

#include <proxy.h>

struct FooDispatch : pro::dispatch<void()> {
  template <class T>
  void operator()(T& value) const {
    value.Foo();
  }
};
struct FooFacade : pro::facade<FooDispatch> {};

struct MyFooStruct {
  void Foo() { puts("Non-const Foo()"); }
  void Foo() const { puts("Const Foo()"); }
};

int main() {
  pro::proxy<FooFacade> p1 = std::make_unique<MyFooStruct>();
  pro::proxy<FooFacade> p2 = std::make_unique<const MyFooStruct>(); // `p1` and `p2` are of the same type
  p1.invoke(); // prints "Non-const Foo()"
  p2.invoke(); // prints "Const Foo()"
  return 0;
}

from proxy.

Thank you for the suggestion @coyorkdow. Actually, proxy already has the capability to differentiate const and non-const expressions, but in a different form from traditional (inheritance-based) polymorphism. Specifically, traditional one requires const on the base type while using it (client shall have the knowledge of const-ness to use a polymorphic object correctly), while proxy only requires const when constructing it (client no longer needs this information anymore, making the API boundary clean).

For example:

#include <cstdio>
#include <memory>

#include <proxy.h>

struct FooDispatch : pro::dispatch<void()> {
  template <class T>
  void operator()(T& value) const {
    value.Foo();
  }
};
struct FooFacade : pro::facade<FooDispatch> {};

struct MyFooStruct {
  void Foo() { puts("Non-const Foo()"); }
  void Foo() const { puts("Const Foo()"); }
};

int main() {
  pro::proxy<FooFacade> p1 = std::make_unique<MyFooStruct>();
  pro::proxy<FooFacade> p2 = std::make_unique<const MyFooStruct>(); // `p1` and `p2` are of the same type
  p1.invoke(); // prints "Non-const Foo()"
  p2.invoke(); // prints "Const Foo()"
  return 0;
}

I see. So from my understanding of this explanation, regarding const and non-const as two different interfaces is somehow a drawback due to the limitation of the inheritance-base polymorphism. The design of the proxy is remove the const semantics on interface level while the client freely chose whether it is const or not.

Am I right? Thank you.

from proxy.

@coyorkdow Yes, I believe so.

from proxy.