«

Hello,

I have a question about passing an object into a constructor.

How can I check to make sure that the object is good/valid that is
being passed into the constructor.

Obviously I could check to see if it is non-NULL, but that still will
not necessarily tell me anything.

For example:

/* here is a constructor car that takes an engine class as an
argument. But, I better check to make sure that engine is valid
so how do I do that?
*/
Car::Car( Engine* engine )
{

// check to make sure that engine is valid.


}


Thanks in advance for any help,
John

wrote:

> I have a question about passing an object into a constructor.
>
> How can I check to make sure that
> the object that is being passed into the constructor is good/valid.
>
> Obviously I could check to see if it is non-NULL
> but that still will not necessarily tell me anything.


class Engine {
private:
// representation
const
unsigned int Valid;
public:
//functions
bool valid(void) const {
return 0x55555555 == Valid;
}
// constructors
Engine(void): Valid(0x55555555) { }
~Engine(void) { Valid = 0xAAAAAAAA; }
};

> For example:
>
> // Here is a constructor car
> // that takes an engine class as an argument.
> // I had better check to make sure that engine is valid.
> // How do I do that?
>
> Car::Car(const Engine& engine) {
> // check to make sure that engine is valid.
> if (engine.valid()) {
> // Initialize *this.
> }
> else { /* Handle error. */ }
> }

In article <>, wrote:

> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.
>
> Obviously I could check to see if it is non-NULL, but that still will
> not necessarily tell me anything.
>
> For example:
>
> /* here is a constructor car that takes an engine class as an
> argument. But, I better check to make sure that engine is valid
> so how do I do that?
> */

What do you mean by "valid" ? The Engine class should be responsible for making
sure that Engine objects are not "invalid".

Since you are passing in a pointer, you need to check for a null pointer.

If the pointer is not null, it's the callers responsibility to pass in a valid
pointer. There's no way to check whether a pointer is "wild" or not.

Cheers,
--
Donovan Rebbechi
http://pegasus.rutgers.edu/~elflord/

<> wrote in message
news:...
> Hello,
>
> I have a question about passing an object into a constructor.
>
> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.
>
> Obviously I could check to see if it is non-NULL,

Unless it's a pointer there's nothing to check, NULL-wise.

> but that still will
> not necessarily tell me anything.
>
> For example:
>
> /* here is a constructor car that takes an engine class as an
> argument. But, I better check to make sure that engine is valid
> so how do I do that?
> */
> Car::Car( Engine* engine )
> {
>
> // check to make sure that engine is valid.

You'll have to ask the Engine object, if it has a member that serves that
purposes. Other than checking whether the supposed memory the object
occupies is real memory, which is a system-specific matter and OT here,
there is no general way to tell if an object is valid. If the Engine itself
can't tell you it's valid, nothing else can.

DW

"E. Robert Tisdale" <> wrote in message
news:...
> wrote:
>
> > I have a question about passing an object into a constructor.
> >
> > How can I check to make sure that
> > the object that is being passed into the constructor is good/valid.
> >
> > Obviously I could check to see if it is non-NULL
> > but that still will not necessarily tell me anything.
>
>
> class Engine {
> private:
> // representation
> const
> unsigned int Valid;
> public:
> //functions
> bool valid(void) const {
> return 0x55555555 == Valid;
> }
> // constructors
> Engine(void): Valid(0x55555555) { }
> ~Engine(void) { Valid = 0xAAAAAAAA; }
> };

Of course, with the same "valid" value used in all instances, and perhaps in
other classes as well, it will greatly increase the probability that some
dangling or uninitialized pointer will be unlucky enough to point somewhere
such that the Valid member happens to be 0x55555555.

DW

<> skrev i en meddelelse
news:...
> Hello,
>
> I have a question about passing an object into a constructor.
>
> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.
>
> Obviously I could check to see if it is non-NULL, but that still will
> not necessarily tell me anything.
>
> For example:
>
> /* here is a constructor car that takes an engine class as an
> argument. But, I better check to make sure that engine is valid
> so how do I do that?
> */
> Car::Car( Engine* engine )
> {
>
> // check to make sure that engine is valid.
>
>
> }
>
>
> Thanks in advance for any help,
> John


Most probably, you need to not use a pointer:

Car::Car(Engine const& engine)

as this will assure a proper engine-object to be passed always.

If "Car" does not need an engine, you could keep your present design.

If Car needs to use an engine, but you for some reason want to keep the
signature of the constructor (the reason for this would not be based in the
language), You should throw from the constructor:

Car::Car( Engine* engine)
{
if (!engine) throw 0; // have a proper exception here!!
// continue construction here
}

but be prepared to refactor later.

I can't really recommend Tisdales trick unless there is a compelling reason
to do it that way (e.g. if you are not allowed to throw an exception in the
constructor).

/Peter

<> wrote in message
news:...
> Hello,
>
> I have a question about passing an object into a constructor.
>
> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.
>
> Obviously I could check to see if it is non-NULL, but that still will
> not necessarily tell me anything.
>
[SNIP]

Well, the whole problem arises from the word "valid". It depends very much
what you define as a valid object. Testing for NULL is a way of checking
whether a pointer is valid but this doesn't tell you whether the object,
which this pointer points to, has a "valid = reasonable" state. If you just
want to check whether the pointer has something to point to then this NULL
test is fine. Otherwise you will have to define what characterizes a
"good/valid" object state and supply some function to check this. (See
Robert Tisdale's post).

Cheers
Chris

<> skrev i meddelandet
news:...
> Hello,
>
> I have a question about passing an object into a constructor.
>
> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.

Why would you like to do that?
IMHO the right way to do it is that in the documentation of the class say
something as:

Car::Car( Engine* engine )
Precondition: engine points to a valid Engine object.

and leave the responsibility for this to the caller. This is the approach
the standard library has.

For example:
18.6.2.3 set_unexpected
unexpected_handler set_unexpected(unexpected_handler f) throw();
1 Effects: Establishes the function designated by fas the current
unexpected_handler.
2 Requires: f shall not be a null pointer.

--
Dag Henriksson

In article <>,
wrote:

> Hello,
>
> I have a question about passing an object into a constructor.
>
> How can I check to make sure that the object is good/valid that is
> being passed into the constructor.
>
> Obviously I could check to see if it is non-NULL, but that still will
> not necessarily tell me anything.
>
> For example:
>
> /* here is a constructor car that takes an engine class as an
> argument. But, I better check to make sure that engine is valid
> so how do I do that?
> */
> Car::Car( Engine* engine )
> {
>
> // check to make sure that engine is valid.
>
>
> }

In other words, you want to guard against someone doing something like:

Car myCar( (Engine*) 0x543562 );

(where 0x543562 doesn't point to an actual Engine object.) Or some such?

There isn't much you can do about this, but here is one idea:

class Engine {
static std::set< Engine* > allEngines;
public:
static bool isValid( Engine* anEngine ) {
return allEngines.count( anEngine ) == 1;
}

Engine() {
allEngines.insert( this );
}
~Engine() {
allEngines.erase( this );
}
};

Now:

Car::Car( Engine* engine ) {
assert( Engine::isValid( engine ) );
//...
}

This is not a cheep operation! It will probably slow your program down
tremondusly if you do this with every class. Be sure to make it so you
can define the extra code out when you build a release version.

"Daniel T." <> skrev i meddelandet
newsostmaster-...
> In other words, you want to guard against someone doing something like:
>
> Car myCar( (Engine*) 0x543562 );
>
> (where 0x543562 doesn't point to an actual Engine object.) Or some such?
>
> There isn't much you can do about this, but here is one idea:

Your idea will probably work on some implementation, but technically is the
effect of using an invalid pointer value undefined and could cause a
system-generated runtime fault.

That means that you can not check if a pointer argument is valid or not
inside a function (or anywhere else). When the pointer is passed to the
function (by value) we have already invoked undefined behavior.

--
Dag Henriksson