Why is the Base class Constructor getting called twice

R

Robert

Hello all...

In my code below, the Notify Constructor and Destructor is getting
called twice and it appears that a new Notify object is created on the
2nd call. The 2nd call is caused by this line below: pNotify = new
EMAILnotify; that lives in the Notification Constructor.

One theory is that the Notify base class is not completely constructed
prior to using it in the Notification Constructor code: pNotify = new
EMAILnotify;

All the code below can be pasted into a *.cpp module and will compile
and run with a VC++6.0 compiler.

Thanks in advance for any clues as to why?

**************************************************************
#include <iostream>
#include <string>

using namespace std;

class Notify
{
public:
Notify(void){ cout << "Constructing Notify: " << this << endl; }
virtual ~Notify(void){ cout << "Destructing Notify: " << this <<
endl; }
virtual void Send() = 0;
};
class Notification : public Notify
{
public:
Notification(void){}
Notification(string sNotifyType);
virtual ~Notification(void);
void Send(){ pNotify->Send(); }
private:
Notify* pNotify;

};
class EMAILnotify : public Notify
{
public:
EMAILnotify(void){}
virtual ~EMAILnotify(void){};
virtual void Send(){ cout << "Send() Email: " << this << endl; }
};
Notification::Notification(string sNotifyType)
{
if(sNotifyType == "EMAIL")
pNotify = new EMAILnotify; // Causes 2nd Constructor call
}
Notification::~Notification(void)
{
if( NULL != pNotify )
delete pNotify;
}

void main()
{
Notification* pNotification = new Notification("EMAIL");
pNotification->Send();
delete pNotification;
}
 
A

Alf P. Steinbach

In my code below, the Notify Constructor and Destructor is getting
called twice and it appears that a new Notify object is created on the
2nd call. The 2nd call is caused by this line below: pNotify = new
EMAILnotify; that lives in the Notification Constructor.

Class Notification derives from Notify. The calling sequence is:
(1) create a Notification object, which executes the Notify constructor,
and then (2) executes the Notification constructor body, which (3)
executes pNotify = new EMAILnotify, which (4) creates an EMAILnotify
object, where EMAILnotify is derived from Notify, so that this creation
(5) executes the Notify constructor for the EMAILnotify object, and (6)
proceeds to execute the EMAILnotify constructor body.

...

**************************************************************
#include <iostream>
#include <string>

using namespace std;

class Notify

This is a bad name for a class. A class doesn't "do" anything,
unless it's a functor class. Which this isn't.

{
public:
Notify(void){ cout << "Constructing Notify: " << this << endl; }

Style.
'void' as an argument list is a C'ism which you'd better forget.


virtual ~Notify(void){ cout << "Destructing Notify: " << this <<
endl; }
virtual void Send() = 0;
};

Style.
At least one empty line between class declarations is a good idea.


class Notification : public Notify
{
public:
Notification(void){}
Notification(string sNotifyType);
virtual ~Notification(void);
void Send(){ pNotify->Send(); }
private:
Notify* pNotify;

};

Style.
The definitions of the Notification member functions should appear
here, before anything more. One "place" per class in the code.

Design.
Having a pNotify member doesn't seem to serve any useful purpose.
Most probably you have tried to implement too much in one class.


class EMAILnotify : public Notify
{
public:
EMAILnotify(void){}
virtual ~EMAILnotify(void){};
virtual void Send(){ cout << "Send() Email: " << this << endl; }
};
Notification::Notification(string sNotifyType)
{
if(sNotifyType == "EMAIL")

Design.
Don't identify types by strings (in general). Use symbolic constants
if you absolutely have to. But even more to the point: don't identify
types by data unless you really Really REALLY have to.

pNotify = new EMAILnotify; // Causes 2nd Constructor call
}
Notification::~Notification(void)
{
if( NULL != pNotify )

Coding.
No need to check for NULL.

delete pNotify;
}

void main()

C++ standard.
'void main' is not allowed. This is not a valid standard C++ program.

{
Notification* pNotification = new Notification("EMAIL");
pNotification->Send();
delete pNotification;

Style.
The above is not exception safe in any sense. Use a std::auto_ptr.
 
G

Gianni Mariani

Robert wrote:
....
Thanks in advance for any clues as to why?

because you inherit notify in two different classes and instantiate both
classes.
**************************************************************
#include <iostream>
#include <string>

using namespace std;

class Notify
{
public:
Notify(void){ cout << "Constructing Notify: " << this << endl; }
virtual ~Notify(void){ cout << "Destructing Notify: " << this <<
endl; }
virtual void Send() = 0;
};
class Notification : public Notify

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ inherit 1
{
public:
Notification(void){}
Notification(string sNotifyType);
virtual ~Notification(void);
void Send(){ pNotify->Send(); }
private:
Notify* pNotify;

};
class EMAILnotify : public Notify


^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ inherit 2

{
public:
EMAILnotify(void){}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ : Notify() implicitly constructed here

virtual ~EMAILnotify(void){};
virtual void Send(){ cout << "Send() Email: " << this << endl; }
};
Notification::Notification(string sNotifyType)
: Notify() // implicit construct of Notify

{
if(sNotifyType == "EMAIL")
pNotify = new EMAILnotify; // Causes 2nd Constructor call
// Making second Notify here
}
Notification::~Notification(void)
{
if( NULL != pNotify )
delete pNotify;
}

void main()

must use int - not void....

int main()
 
K

Karl Heinz Buchegger

Robert said:
Hello all...

In my code below, the Notify Constructor and Destructor is getting
called twice and it appears that a new Notify object is created on the
2nd call. The 2nd call is caused by this line below: pNotify = new
EMAILnotify; that lives in the Notification Constructor.

One theory is that the Notify base class is not completely constructed
prior to using it in the Notification Constructor code: pNotify = new
EMAILnotify;

The ctor is called twice because you create 2 Notify objects.

Object 1:
Notification* pNotification = new Notification("EMAIL");

Object 2: inside the ctor of Notification
pNotify = new EMAILnotify;

It seems you have a design error. From what I can see, you don't
want a Notification object to be a Notify object at the same time.
A Notification object *contains* a Notify object, but that's it. A
Notification is not a Notify on its own.

class Notification
{
....

Notify* pNotify;
};
 
R

Robert

Class Notification derives from Notify. The calling sequence is:
(1) create a Notification object, which executes the Notify constructor,
and then (2) executes the Notification constructor body, which (3)
executes pNotify = new EMAILnotify, which (4) creates an EMAILnotify
object, where EMAILnotify is derived from Notify, so that this creation
(5) executes the Notify constructor for the EMAILnotify object, and (6)
proceeds to execute the EMAILnotify constructor body.

Thanks for all the information and tips...
This is a bad name for a class. A class doesn't "do" anything,
unless it's a functor class. Which this isn't.

Agreed!...


Style.
'void' as an argument list is a C'ism which you'd better forget.

Agreed!, that's what I get for cutting and pasting sample code.
Style.
At least one empty line between class declarations is a good idea.

This was a post, need to keep it short.
Style.
The definitions of the Notification member functions should appear
here, before anything more. One "place" per class in the code.

Again, this was a post, the real code is in separate modules.
Design.
Having a pNotify member doesn't seem to serve any useful purpose.
Most probably you have tried to implement too much in one class.

pNotify as a member is vital in supporting the strategy pattern.
Please correct me if I'm wrong.
Design.
Don't identify types by strings (in general). Use symbolic constants
if you absolutely have to. But even more to the point: don't identify
types by data unless you really Really REALLY have to.

Agreed!, but then how would I identify a type at run time via
polymorphism?
Coding.
No need to check for NULL.

Yep!


C++ standard.
'void main' is not allowed. This is not a valid standard C++ program.

When I test sample code, no need to worry about Standards that would
not cause bugs...
Style.
The above is not exception safe in any sense. Use a std::auto_ptr.

This is sample code, in the real program it is wrapped in a
try{}catch{}


Thanks again for your tips...

--Robert
 
K

Karl Heinz Buchegger

Robert said:
Agreed!, but then how would I identify a type at run time via
polymorphism?

By not identifying them at all.
In your case: Why pass a string identifying the type of notify
when you can pass a Notify object at the same time.

class Notification
{
public:
Notification( Notify* pNotify ) : m_pNotify( pNotify ) {}
~Notification() { delete pNotify; }
void Send() { m_pNotify->Send(); }
...

private:
Notify* m_pNotify;
};

class Notify
{
public:
virtual ~Notify();
...
virtual void Send() = 0;
};

class EMailNotify : public Notify
{
public:
EMailNotify( std::string& To ) : m_To( To ) {}
...
virtual void Send() { std::cout << "Sending EMail to " << m_To << std::endl;

private:
std::string m_To;
};

class SnailMailNotify : public Notify
{
public:
SnailMailNotify( std::String& To ) : m_To( To ) {}
...
virtual void Send() { std::cout << "Sending snail mail to " << m_To << std::endl;

private:
std::string m_To;
};


int main()
{
Notification* pEvent1 = new Notification( new EmailNotification( "(e-mail address removed)" ) );
Notification* pEvent2 = new Notification( new SnailMailNotify( "Robert" ) );

pEvent1->Send();
pEvent2->Send();
When I test sample code, no need to worry about Standards that would
not cause bugs...

If you post in this group and use void main() you will always get a reply
for that. Plain and simple: void main() is wrong. The fact that your
compiler allows you to use it is irrelevant. It is still wrong.
 
J

jb

Class Notification derives from Notify. The calling sequence is:
(1) create a Notification object, which executes the Notify constructor,
and then (2) executes the Notification constructor body, which (3)
executes pNotify = new EMAILnotify, which (4) creates an EMAILnotify
object, where EMAILnotify is derived from Notify, so that this creation
(5) executes the Notify constructor for the EMAILnotify object, and (6)
proceeds to execute the EMAILnotify constructor body.



This is a bad name for a class. A class doesn't "do" anything,
unless it's a functor class. Which this isn't.



Style.
'void' as an argument list is a C'ism which you'd better forget.




Style.
At least one empty line between class declarations is a good idea.




Style.
The definitions of the Notification member functions should appear
here, before anything more. One "place" per class in the code.

Design.
Having a pNotify member doesn't seem to serve any useful purpose.
Most probably you have tried to implement too much in one class.




Design.
Don't identify types by strings (in general). Use symbolic constants
if you absolutely have to. But even more to the point: don't identify
types by data unless you really Really REALLY have to.



Coding.
No need to check for NULL.



C++ standard.
'void main' is not allowed. This is not a valid standard C++ program.



Style.
The above is not exception safe in any sense. Use a std::auto_ptr.

Well that was a great help, its cleared up any queries as to why the
c'tor was being called twice!
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top