C++Talk.NET

Michael D. Borghardt · Guest

Hi I am looking at this from a clients perpective

void main()
{
Base * base = new Base();
DerivedFromBase * derived = new DerivedBase();

// Function documented that parameter must be greater than 5
base->foo(X);

// Function documented that parameter must be greater than 3
derived->foo(X);

. . .

Base * converted = derived;

// What do you think the client expects
converted->foo(X);
}

What I and really trying to figure out is how preconditions can be inherited
when conversion takes place.

Since converted ISA base then wouldn't a client have to used the method with
the assumption from class Base that it must be > 5?

I know this may more of an OO than a C++ questions but I have some
implementation ideas that would follows given the answers that I receive.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

WW · Guest

Michael D. Borghardt wrote:

Marcelo Pinto · Guest

"Michael D. Borghardt" <michael (AT) borghardtConsulting (DOT) net> wrote

[snip]

Siemel Naran · Guest

"Michael D. Borghardt" <michael (AT) borghardtConsulting (DOT) net> wrote in message

James Kanze · Guest

"Michael D. Borghardt" <michael (AT) borghardtConsulting (DOT) net> writes:

Michael D. Borghardt · Guest

Hi.

Thanks for you opinion

So here is the idea taken from various places

Part of assertions.h

// Customed assertion handler
void onAssertion__(char const * expression, char const * file, unsigned
line);

// Create filename string once per source file
#define DEFINE_THIS_FILE
static char const THIS_FILE__[] = __FILE__;

// Base Assertion that calls assertion handler if false
#define ASSERTION(test_)
((test_) ? (void)0 : onAssertion__(#test_, THIS_FILE__, __LINE__))

// tests that causes Side-effects
#define ALLEGE(test_) ASSERTION(test_)

// Preconsitions
#define REQUIRE(test_) ASSERTION(test_)
// Postconditions
#define ENSURE(test_) ASSERTION(test_)
// Invariants
#define INVARIANT(test_) ASSERTION(test_)
#endif

base.h

class Base
{
public:
void func(int i)
{
INVARIANT(invariant());
// preconditions
REQUIRE(i > 0);
funcImp();
// postconditions
ENSURE(i > 0);
INVARIANT(invariant());
}
protected:
// protected and pure so it must implement in derived and must call this
classes function
virtual bool invariant() = 0 {return true;}

void funcImp() { funcImp1(); funcImp2();}
private:
// must be implemented in derived but cannot call this classes function
virtual void funcImp1() = 0;
virtual void funcImp2() = 0;
};

Part of derived.h

class Derived : public Base
{
public:
void func(int i)
{
INVARIANT(invariant());
// preconditions
REQUIRE(i >= 0);
funcImp();
// postconditions
ENSURE(i >= 0);
INVARIANT(invariant());
}
protected:
virtual bool invariant() {return Base::invariant() && true;}
private:
virtual void funcImp1();
virtual void funcImp2();
};

The good thing I see about this is that the DBC is defined in the header
file that others can see

The Bad thing I see is that the conditions are not enfored to weakened or
strengthened at compile-time so it it up to the programmer to ensure the
correct context.

Another bad thing is that In the dreived class it does not have access the
base class condtions AND private variables

So I am startign to think that I will have to have pre and post condtion
functions that can be called up the hierarchy and OR the precondtions and
AND the post conditions

From an implementation point of view I see this as a grand preprocessor
exercise, any thoughts.

BTW Does anyone know if/how Eiffel makes sure the conditions do not conflict
eash other ie

in base require i >0 and in derfived require i < 0

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Adam H. Peterson · Guest

<snip>

Javier Estrada · Guest

Michael,

I think a more correct forum would be one with OO. There are several
methodologists active in other newsgroups that deal with some of these
concepts.

A design pattern that deals with your post is the Percolation Pattern.
It is published in the book Testing Object-Oriented Systems, by V.
Binder and also appeared in C++ Report a few years ago.

In addition, the design by contract concepts are nicely tackled in,
well, design Smile

. The Object Constraint Language, now part of UML,
gives some guidelines that can be used for invariants, preconditions
and postconditions. I'll try to summarize them here:

- An invariant for a superclass is inherited by its subclasses. A
subclass may strengthen the invariant but cannot weaken it.

- A precondition may be weakened, not strengthened, in a redefinition
of an operation in a subclass.

- A postcondition may be strengthened, not weakened, in a redefinition
of an operation in a subclass.

The Percolation Pattern basically adheres to these statements in the
presence of class hierarchies and multiple inheritance.

Here's the Amazon link for the books:

http://www.amazon.com/exec/obidos/external-search/104-5230100-9933527?tag=opera-20&index=blended&keyword=Testing+Object-Oriented+Systems

I couldn't get the other link. It seems somebody hacked amazon--it
displays FOO :-)

Regards,

Javier Estrada

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

John Kewley · Guest