🚀 go-pugleaf

Hi,

Rich Hickey (hickeyr@ibm.net) wrote:
[Explanation of the proposal removed]

: class B{
: public:
:    virtual int foo()const=0;
:    //...
: };

: explicit class D:public B{
: public:
:   int foo()const{return data;}
:   //...
: private:
:   int data;
: };

: void fred(const D &d)
:    {
:    d.foo();  //as if d.D::foo(); - inlined
:    }

: void ethel(const B &b)
:   {
:   b.foo();	//even if b is a D, virtual function call (as always)
:   }


: It cannot be otherwise accomplished in the language, i.e. it requires an extension.

I think it is easy to accomplish the thing you want to do in the language:

  class E: public B {
  public:
    int foo_inline() const { return data; }
    int foo() const        { foo_inline(); }
  private:
    int data;
  };

  void foo(E const &e)
  {
    e.foo_inline(); // inline. Note that you know exactly the type of 'e'
    e.foo();        // virtual as ever
  }

Although I agree with you that your proposal is nicer to use, your
claim that it cannot be implemented in the language is wrong...
However, it would be nice to have a simple possibility to close a class
for further derivation (I know that it is possible using a friend and a
virutal base class but I think that this could even impose some runtime
penalty due to the representation of virtual bases).
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl
I am a realistic optimist - that's why I appear to be slightly pessimistic

[ To submit articles: Try just posting with your newsreader.
		      If that fails, use mailto:std-c++@ncar.ucar.edu
  FAQ:    http://reality.sgi.com/employees/austern_mti/std-c++/faq.html
  Policy: http://reality.sgi.com/employees/austern_mti/std-c++/policy.html
  Comments? mailto:std-c++-request@ncar.ucar.edu
]