C / C++ / MFC

Re: How to Create Single Process in C++

16-Oct-13 6:52

Take a look at this: Avoiding Multiple Instances of an Application[^]

"Real men drive manual transmission" - Rajesh.

Thong LeTrung16-Oct-13 6:58

Thong LeTrung

16-Oct-13 6:58

Thank you a lot
Thong LT

How does this code with "event" functions?

Vaclav_16-Oct-13 6:38

16-Oct-13 6:38

Could someone tell me what is going on here? Please.

I am trying to output audio frequency using waveOutWrite. I am using callback function.
Works as expected.
Now I would like to output the audio using the “loop” parameter in the header.
The header sets WHDR_DONE flag when the loop is done.

Now I needed to “translate “ WHDR_DONE flag to the callabck WOM_DONE message for further processing .

I couldn't make the callback work on event so I used this.( I'll try it again).

<b>I have used this „event“ , it partially works but I have no idea why.</b>

HANDLE event;
event = CreateEvent(NULL, TRUE, FALSE, NULL);
DWORD dwWaitResult;

Callback function:

void CALLBACK C_AssynchPlay2::CallbackWaveOutProc(HWAVEOUT hwo,
UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
TRACE("\nvoid CALLBACK C_AssynchPlay2::CallbackWaveOutProc...");
if (uMsg == WOM_DONE)
{
AfxMessageBox("finished "); // gets here
return;
}

Output audio function:

bRC = TRUE;
TRACE("\nInitialize pcm %i ",i );
pcm[i].lFreq = Freq;
pcm[i].dDelay = 1; // Delay; must be < 1
pcm[i].whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP ;
pcm[i].whdr.dwLoops = 5; // works

if(!pcm[i].C_CreateSinus())
TRACE("\nFailed pcm[i].C_CreateSinus() %i ", i );

HANDLE event;
event = CreateEvent(NULL, TRUE, FALSE, NULL);
DWORD dwWaitResult;

mmres = waveOutPrepareHeader(hwout, & pcm[i].whdr, sizeof(WAVEHDR));
if (mmres != MMSYSERR_NOERROR) {ASSERT(0); bOK = FALSE;}

mmres = waveOutWrite(hwout, & pcm[i].whdr, sizeof(WAVEHDR));

TRACE("\nWait event ");
dwWaitResult = WaitForSingleObject(event,INFINITE); //sets WOM_DONE in callback

From here this code never gets processed

TRACE("\nWait event OK ");
AfxMessageBox("Wait event.... ");
return bRC;

Many thanks for your help.

Cheers
Vaclav

Rajesh R Subramanian16-Oct-13 9:05

16-Oct-13 9:05

Vaclav_Sal wrote:
dwWaitResult = WaitForSingleObject(event,INFINITE); //sets WOM_DONE in callback

You're waiting for an event to be set for an infinite amount of time. I think that it's not returning because the event is never set, and as such the code doesn't progress further to execute your AfxMessageBox.

Have you verified that the WaitForSingleObject call actually returns?

"Real men drive manual transmission" - Rajesh.

Vaclav_16-Oct-13 14:36

16-Oct-13 14:36

That is my main question. When I comment the WaitForSingleObject out the WOM_DONE get set immediatelly after the waveOutWrite. Not waiting for the header loop flag to indicate completion of the loop. There is no mechanism to control that in that case.

It all indicates that the event never gets set as you pointed out.
I have not checked for memory leaks either, mainly beacause the CALLBACK process function gets terminated , for now.
I think I need to go back to try CALLBACK on event instead of just plain CALLBACK function.

Rajesh R Subramanian16-Oct-13 19:15

16-Oct-13 19:15

In the case you've provided, the WaitForSingleObject will wait forever (due to the INFINITE time specification), or until the event that's it's waiting on to be "set". Ideally, you should be changing the state of this event in another thread, and the wait will end.

Are you performing everything in the same thread? That's not how it's intended to work.

"Real men drive manual transmission" - Rajesh.

Vaclav_17-Oct-13 8:59

17-Oct-13 8:59

Yes, it is all done in the same thread.

This callback function starts the audio process and "monitors" the completion of the audio buffer which is set to output about 1 second of audio.

mmres = waveOutOpen(&hwout, WAVE_MAPPER, &wfme,
(DWORD) CallbackWaveOutProc, 0x12345, CALLBACK_FUNCTION);

The issue is that I want to utilize "loop" feature of this audio buffer and output the audio for more then 1 second. Without the "wait for event" the waveOutWrite returns immediately after the audio output starts, setting the WOM_DONE in the callback function.
Inserting the wait for event let the waveOutWrite generate the WOM_DONE AFTER the WHDR_DONE is asserted.
I did write simple wait loop to monitor this WHDR_DONE flag and it worked, but I thought I could use Windows event to do same. It does what I want, but I just do not understand how it does it.

Vaclav

Disk Wipe

Member 862075915-Oct-13 23:52

Member 8620759

15-Oct-13 23:52

I want to write program which would completely wipe out my hard disk and the data on the hard disk should not be recoverable once wiped. I want to implement this in c/c++.

http://security.stackexchange.com/questions/15757/writing-file-shredder[^]

Member 862075916-Oct-13 2:11

Member 8620759

16-Oct-13 2:11

Vaclav_16-Oct-13 14:43

16-Oct-13 14:43

I would guess that the only totally wipe would be using "format".
Definitely not in favor of the above link "toy program".

SoMad16-Oct-13 17:17

SoMad

16-Oct-13 17:17

Step 1: Backup your drives. Smile | :)

This is meant as a humorous reminder. Seriously, don't run a single test before you are sure you have a working backup.

Soren Madsen

"When you don't know what you're doing it's best to do it quickly" - Jase #DuckDynasty

Albert Holguin17-Oct-13 5:33

Albert Holguin

17-Oct-13 5:33

There's an open source project called DBAN that does this...

http://www.dban.org/[^]
http://en.wikipedia.org/wiki/Darik's_Boot_and_Nuke[^]

Since it's open source, you should be able to look through the source to see how they accomplish this (if you're trying to learn). If you're just trying to blast some old disks, you can just download it and use it, it works VERY WELL (be careful).

Polymorphism & Assignment Op. & Copy Constructors in C++

TheKingofdemon3318-Oct-13 9:14

TheKingofdemon33

18-Oct-13 9:14

There is no way to make data completely unrecoverable. But using some shredding algorithms you can slow down the process of recovery of the shredded(deleted) data.

federico.strati15-Oct-13 2:16

federico.strati

15-Oct-13 2:16

The following question is about how to handle assignment operators (& copy constructors)
in a hierarchy of polymorphic objects in order to be able to work with all kind of assignments & copy:
i.e. we would ideally like to work always with base class pointers, but also allow to use
directly derived class pointers.

In fact I do present two techniques to deal with this argument:

A) The first does make use of "virtual" assignment operators
and, as far as I know, should be the "standard" way to deal with this argument in C++,
but it has the drawback that as soon as your hierarchy is more than one level deep
it leads to a combinatorial explosion of assignment operators.

This technique I call "Polymorphism A" in the following.

B) The second technique does make use of an aux virtual copy method,
using this aux virtual copy method fewer assignment operators have to be defined,
but it has the drawback that you cannot call directly the base class assignment op. from derived ones.

This technique I call "Polymorphism B" in the following.

My question is more like an open discussion: i.e. I do ask what are your opinions on both techniques,
what drawbacks you may see in them, and, eventually, if you do know of a better way to solve the same problem.

In the sample code I give objects are relatively simple, but keep in mind that we would like
to apply those techniques to complicated objects where "deep" copies are to be used.

Let us see the code:
------- Polymorphism A - hierarchy --------------------

C++

// PolymorphismA.cpp

#include "stdafx.h"

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>

using namespace std;

// We want, inasmuch as possible, to work only with CBase pointers
// but we have a hierarchy based on CBase derived classes

class CBase // CBase is our base class
{
private:
   CBase() // default ctor is protected, we do not want to default construct
   { cout << "CBase() default ctor called" << endl; 
     _data = -1; _isvalid = false; };

public:
   explicit CBase(const int data) // explicit Construction
   { cout << "CBase(const int data) explicit ctor called" << endl; 
     _data = data; _isvalid = true; };
   virtual ~CBase() // polymorphism, virtual dtor
   { cout << "~CBase() dtor called" << endl; };

public:
   // CBase and derived objects are copy-constructible and assignable through base pointers
   CBase(const CBase& iOther) // it cannot be declared as virtual
   { cout << "CBase(const CBase& iOther) copy ctor called" << endl; 
     copyBase(iOther); // copy the base
   };
   virtual CBase& operator=(const CBase& iOther) // we declare it as virtual
   { cout << "CBase& CBase::operator=(const CBase& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        copyBase(iOther); // copy the base
     }
     return *this;
   };

private:
   // Aux Method to copy the base class, common to copy ctor and assignment op.
   void copyBase(const CBase& iOther)
   { cout << "CBase::copyBase() copy called" << endl; 
     _data = iOther._data; _isvalid = iOther._isvalid; };

public: // we also have real methods
   int getData() const // Accessor
   { return _data; };
   void setData(const int data) // Setter
   { _data = data; };
   bool isValid() const // Accessor
   { return _isvalid; };
   void setValid(const bool isvalid) // Setter
   { _isvalid = isvalid; };

private:
   int _data;     // CBase state
   bool _isvalid; // CBase state
};

class CDerivedA : public CBase // CDerivedA is derived from CBase interface
{
private:
   CDerivedA() // default ctor is protected, we do not want to default construct
      : CBase((int) -1)
   { cout << "CDerivedA() default ctor called" << endl; 
     _dataA = -1.0; setValid(false); };

public:
   explicit CDerivedA(const double dataA) // explicit Construction
      : CBase((int) 0) // explicitly invoke base constructor
   { cout << "CDerivedA(const double dataA) explicit ctor called" << endl; 
     _dataA = dataA; };
   virtual ~CDerivedA() // polymorphism, virtual dtor
   { cout << "~CDerivedA() dtor called" << endl; };

public:
   // Also CDerivedA are copy-constructible and assignable in case we work directly with pointers to CDerivedA
   // We need Specific to this class copy ctor & assignment op.
   CDerivedA(const CDerivedA& iOther) // it cannot be declared as virtual
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedA(const CDerivedA& iOther) copy ctor called" << endl; 
     _dataA = iOther._dataA; // our specific data copy
   };
   virtual CDerivedA& operator=(const CDerivedA& iOther) // declared as virtual for further derivation
   { cout << "CDerivedA& CDerivedA::operator=(const CDerivedA& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // We may call the base class assignment operator... as in
        this->CBase::operator=(iOther);
        // ... or we may call the base copy ctor
        // this->CBase::CBase(iOther);
        _dataA = iOther._dataA; // our specific data copy
     }
     return *this;
   };
   // Define a new copy ctor if we are passed the base class pointer
   CDerivedA(const CBase& iOther)
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedA(const CBase& iOther) copy ctor called" << endl;
     // our specific data copy
     // here we do the derived class copy, but we have a CBase object to deal with...
     // we need to see if we are of the same kind.
     buildVirtualCopy(iOther);
   };
   // Override the base class assignment operator
   virtual CBase& operator=(const CBase& iOther) // declared as virtual in base class
   { cout << "CBase& CDerivedA::operator=(const CBase& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // We may call the base class assignment operator... as in
        this->CBase::operator=(iOther);
        // ... or we may call the base copy ctor
        // this->CBase::CBase(iOther);
        // our specific data copy
        // here we do the derived class copy, but we have a CBase object to deal with...
        // we need to see if we are of the same kind.
        buildVirtualCopy(iOther);
     }
     return *this;
   };

private:
   // aux method
   void buildVirtualCopy(const CBase& iOther)
   {
      cout << "CDerivedA::buildVirtualCopy copy ctor called" << endl;
      // try to down-cast to our type
      const CDerivedA* pOther = dynamic_cast<const CDerivedA*> (&iOther);
      if ( nullptr != pOther ) // we are of the same kind
      {
         // do the copy
         _dataA = pOther->_dataA;
      } 
      else // deal with different object kind
      {
         cout << "CDerivedA: explicit conversion from other type is forbidden" << endl;
         setValid(false); // here we just set the copy as invalid
         // but we could also have thrown an exception
         // ... or defined an explicit conversion policy from other types
      }
   };

public: // we have also real methods
   double getDataA() const // Accessor
   { return _dataA; };
   void setDataA(const double dataA) // Setter
   { _dataA = dataA; };

private:
   double _dataA; // CDerivedA state
};

class CDerivedB : public CBase // CDerivedB is derived from CBase interface
{
private:
   CDerivedB() // default ctor is protected, we do not want to default construct
      : CBase((int) -1)
   { cout << "CDerivedB() default ctor called" << endl; 
     _dataB = ""; setValid(false); };

public:
   explicit CDerivedB(const string dataB) // explicit Construction
      : CBase((int) 1) // explicitly invoke base constructor
   { cout << "CDerivedB(const string dataB) explicit ctor called" << endl; 
     _dataB = dataB; };
   virtual ~CDerivedB() // polymorphism, virtual dtor
   { cout << "~CDerivedB() dtor called" << endl; };

public:
   // Also CDerivedB are copy-constructible and assignable in case we work directly with pointers to CDerivedB
   // We need Specific to this class copy ctor & assignment op.
   CDerivedB(const CDerivedB& iOther) // it cannot be declared as virtual
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedB(const CDerivedB& iOther) copy ctor called" << endl; 
     _dataB = iOther._dataB; // our specific data copy
   };
   virtual CDerivedB& operator=(const CDerivedB& iOther) // declared as virtual for further derivation
   { cout << "CDerivedB& CDerivedB::operator=(const CDerivedB& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // We may call the base class assignment operator... as in
        this->CBase::operator=(iOther);
        // ... or we may call the base copy ctor
        // this->CBase::CBase(iOther);
        _dataB = iOther._dataB; // our specific data copy
     }
     return *this;
   };
   // Define a new copy ctor if we are passed the base class pointer
   CDerivedB(const CBase& iOther)
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedB(const CBase& iOther) copy ctor called" << endl;
     // our specific data copy
     // here we do the derived class copy, but we have a CBase object to deal with...
     // we need to see if we are of the same kind.
     buildVirtualCopy(iOther);
   };
   // Override the base class assignment operator
   virtual CBase& operator=(const CBase& iOther) // declared as virtual in base class
   { cout << "CBase& CDerivedB::operator=(const CBase& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // We may call the base class assignment operator... as in
        this->CBase::operator=(iOther);
        // ... or we may call the base copy ctor
        // this->CBase::CBase(iOther);

        // our specific data copy
        // here we do the derived class copy, but we have a CBase object to deal with...
        // we need to see if we are of the same kind.
        buildVirtualCopy(iOther);
     }
     return *this;
   };

private:
   // aux method
   void buildVirtualCopy(const CBase& iOther)
   {
      cout << "CDerivedB::buildVirtualCopy copy ctor called" << endl;
      // try to down-cast to our type
      const CDerivedB* pOther = dynamic_cast<const CDerivedB*> (&iOther); 
      if ( nullptr != pOther ) // we are of the same kind
      {
         // do the copy
         _dataB = pOther->_dataB;
      } 
      else // deal with different object kind
      {
         // let us look for a type we know of (cross-cast)
         // try to down-cast to this other type
         const CDerivedA* pOtherA = dynamic_cast<const CDerivedA*> (&iOther); 
         if ( nullptr != pOtherA ) // we know about this type
         {
            // do a conversion copy
            stringstream ss;
            ss << setw(4) << pOtherA->getDataA();
            _dataB = ss.str();
            cout << "CDerivedB: explicit conversion from CDerivedA type" << endl;
         } 
         else // deal with different object kind
         {
            setValid(false); // here we just set the copy as invalid
            // but we could also have thrown an exception
         }
      }
   };

public: // we have also real methods
   string getDataB() const // Accessor
   { return _dataB; };
   void setDataB(const string& dataB) // Setter
   { _dataB = dataB; };

private:
   string _dataB; // CDerivedB state
};

------- Polymorphism A - hierarchy --------------------

------- Polymorphism B - hierarchy --------------------

C++

// PolymorphismB.cpp

#include "stdafx.h"

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>

using namespace std;

// We want, inasmuch as possible, to work only with CBase pointers
// but we have a hierarchy based on CBase derived classes

class CBase // CBase is our base class
{
private:
   CBase() // default ctor is protected, we do not want to default construct
   { cout << "CBase() default ctor called" << endl; 
     _data = -1; _isvalid = false; };

public:
   explicit CBase(const int data) // explicit Construction
   { cout << "CBase(const int data) explicit ctor called" << endl; 
     _data = data; _isvalid = true; };
   virtual ~CBase() // polymorphism, virtual dtor
   { cout << "~CBase() dtor called" << endl; };

public:
   // CBase and derived objects are copy-constructible and assignable through base pointers
   CBase(const CBase& iOther) // it cannot be declared as virtual
   { cout << "CBase(const CBase& iOther) copy ctor called" << endl; 
     copyBase(iOther); // copy the base
     // it does not know about other types, No need to call virtual copy
   };
   CBase& operator=(const CBase& iOther) // invoking virtual copy method
   { cout << "CBase& CBase::operator=(const CBase& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        copyBase(iOther); // copy the base
        buildVirtualCopy(iOther); // Delegate to virtual copy if needed
     }
     return *this;
   };

private:
   // Aux Method to copy the base class
   void copyBase(const CBase& iOther)
   { cout << "CBase::copyBase() copy called" << endl; 
     _data = iOther._data; _isvalid = iOther._isvalid; };

protected:
   // Aux Method for derived classes copy
   virtual void buildVirtualCopy(const CBase& iOther) // do nothing in base class
   { cout << "CBase::buildVirtualCopy copy ctor called, it does nothing" << endl; };

public: // we also have real methods
   int getData() const // Accessor
   { return _data; };
   void setData(const int data) // Setter
   { _data = data; };
   bool isValid() const // Accessor
   { return _isvalid; };
   void setValid(const bool isvalid) // Setter
   { _isvalid = isvalid; };

private:
   int _data;     // CBase state
   bool _isvalid; // CBase state
};

class CDerivedA : public CBase // CDerivedA is derived from CBase interface
{
private:
   CDerivedA() // default ctor is protected, we do not want to default construct
      : CBase((int) -1)
   { cout << "CDerivedA() default ctor called" << endl; 
     _dataA = -1.0; setValid(false); };

public:
   explicit CDerivedA(const double dataA) // explicit Construction
      : CBase((int) 0) // explicitly invoke base constructor
   { cout << "CDerivedA(const double dataA) explicit ctor called" << endl; 
     _dataA = dataA; };
   virtual ~CDerivedA() // polymorphism, virtual dtor
   { cout << "~CDerivedA() dtor called" << endl; };

public:
   // Also CDerivedA are copy-constructible and assignable in case we work directly with pointers to CDerivedA
   // We need Specific to this class copy ctor & assignment op.
   CDerivedA(const CDerivedA& iOther) // it cannot be declared as virtual
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedA(const CDerivedA& iOther) copy ctor called" << endl; 
     _dataA = iOther._dataA; // our specific data copy
   };
   CDerivedA& operator=(const CDerivedA& iOther)
   { cout << "CDerivedA& CDerivedA::operator=(const CDerivedA& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // if we call the base class assignment operator... as in
        // this->CBase::operator=(iOther);
        // then we will invoke as well our virtual copy...
        // hence we cannot call the base class assignment operator.
        // but we can do this...
        this->CBase::CBase(iOther); // call the base copy ctor
        _dataA = iOther._dataA; // our specific data copy
     }
     return *this;
   };
   // Define a new copy ctor for the base class pointers
   CDerivedA(const CBase& iOther)
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedA(const CBase& iOther) copy ctor called" << endl; 
     // here we do the derived class copy, but we have a CBase object to deal with...
     // we need to see if we are of the same kind.
     buildVirtualCopy(iOther);
   };

protected:
   // aux method
   virtual void buildVirtualCopy(const CBase& iOther)
   {
      cout << "CDerivedA::buildVirtualCopy copy ctor called" << endl;
      // try to down-cast to our type
      const CDerivedA* pOther = dynamic_cast<const CDerivedA*> (&iOther); 
      if ( nullptr != pOther ) // we are of the same kind
      {
         // do the copy
         _dataA = pOther->_dataA;
      } 
      else // deal with different object kind
      {
         cout << "CDerivedA: explicit conversion from other type is forbidden" << endl;
         setValid(false); // here we just set the copy as invalid
         // but we could also have thrown an exception
         // ... or defined an explicit conversion policy from other types
      }
   };

public: // we have also real methods
   double getDataA() const // Accessor
   { return _dataA; };
   void setDataA(const double dataA) // Setter
   { _dataA = dataA; };

private:
   double _dataA; // CDerivedA state
};

class CDerivedB : public CBase // CDerivedB is derived from CBase interface
{
private:
   CDerivedB() // default ctor is protected, we do not want to default construct
      : CBase((int) -1)
   { cout << "CDerivedB() default ctor called" << endl; 
     _dataB = ""; setValid(false); };

public:
   explicit CDerivedB(const string dataB) // explicit Construction
      : CBase((int) 1) // explicitly invoke base constructor
   { cout << "CDerivedB(const string dataB) explicit ctor called" << endl; 
     _dataB = dataB; };
   virtual ~CDerivedB() // polymorphism, virtual dtor
   { cout << "~CDerivedB() dtor called" << endl; };

public:
   // Also CDerivedB are copy-constructible and assignable in case we work directly with pointers to CDerivedB
   // We need Specific to this class copy ctor & assignment op.
   CDerivedB(const CDerivedB& iOther) // it cannot be declared as virtual
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedB(const CDerivedB& iOther) copy ctor called" << endl; 
     _dataB = iOther._dataB; // our specific data copy
   };
   CDerivedB& operator=(const CDerivedB& iOther)
   { cout << "CDerivedB& CDerivedB::operator=(const CDerivedB& iOther) assignment called" << endl; 
     if( this != &iOther ) // prevents self-assignment
     {
        // if we call the base class assignment operator... as in
        // this->CBase::operator=(iOther);
        // then we will invoke as well our virtual copy...
        // hence we cannot call the base class assignment operator.
        // but we can do this...
        this->CBase::CBase(iOther); // call the base copy ctor
        _dataB = iOther._dataB; // our specific data copy
     }
     return *this;
   };
   // Override the base class copy ctor & assignment op.
   CDerivedB(const CBase& iOther) // it cannot be declared as virtual
      : CBase(iOther) // copy the base by calling the base copy ctor
   { cout << "CDerivedB(const CBase& iOther) copy ctor called" << endl; 
     // copyBase(iOther); // we cannot use directly this base method, otherwise default ctor invoked
     // here we do the derived class copy, but we have a CBase object to deal with...
     // we need to see if we are of the same kind.
     buildVirtualCopy(iOther);
   };

protected:
   // aux method
   virtual void buildVirtualCopy(const CBase& iOther)
   {
      cout << "CDerivedB::buildVirtualCopy copy ctor called" << endl;
      // try to down-cast to our type
      const CDerivedB* pOther = dynamic_cast<const CDerivedB*> (&iOther); 
      if ( nullptr != pOther ) // we are of the same kind
      {
         // do the copy
         _dataB = pOther->_dataB;
      } 
      else // deal with different object kind
      {
         // let us look for a type we know of (cross-cast)
         // try to down-cast to this other type
         const CDerivedA* pOtherA = dynamic_cast<const CDerivedA*> (&iOther); 
         if ( nullptr != pOtherA ) // we know about this type
         {
            // do a conversion copy
            stringstream ss;
            ss << setw(4) << pOtherA->getDataA();
            _dataB = ss.str();
            cout << "CDerivedB: explicit conversion from CDerivedA type" << endl;
         } 
         else // deal with different object kind
         {
            setValid(false); // here we just set the copy as invalid
            // but we could also have thrown an exception
         }
      }
   };

public: // we have also real methods
   string getDataB() const // Accessor
   { return _dataB; };
   void setDataB(const string& dataB) // Setter
   { _dataB = dataB; };

private:
   string _dataB; // CDerivedB state
};

------- Polymorphism B - hierarchy --------------------

and a simple test program to test both of them:

------- test program for both hierarchies -------------

C++

// Now let us play with our types
int _tmain(int argc, _TCHAR* argv[])
{
   cout << "Program starts..." << endl;
   cout << endl;

   {
      CDerivedA* pA0 = new CDerivedA((double) 1.0);
      CDerivedA* pA1 = new CDerivedA((double) 2.0);
      CDerivedB* pB0 = new CDerivedB(string("This is B1"));
      CDerivedB* pB1 = new CDerivedB(string("This is B2"));
      cout << endl;

      CBase* p00 = nullptr;
      CBase* p01 = nullptr;

      // Assignment via base pointers of type A objects
      cout << "Assignment via base pointers of type A objects" << endl;
      p00 = pA0;
      p01 = pA1;
      // A0 <-- A1
      *p00 = *p01;
      cout << "pA0 dataA = " << pA0->getDataA() << endl;
      cout << "pA1 dataA = " << pA1->getDataA() << endl;
      cout << endl;

      p00 = nullptr;
      p01 = nullptr;

      // Assignment via base pointers of type B objects
      cout << "Assignment via base pointers of type B objects" << endl;
      p00 = pB0;
      p01 = pB1;
      // B0 <-- B1
      *p00 = *p01;
      cout << "pB0 dataB = " << pB0->getDataB() << endl;
      cout << "pB1 dataB = " << pB1->getDataB() << endl;
      cout << endl;

      p00 = nullptr;
      p01 = nullptr;

      // "cross assignment": from B type to A type is forbidden
      cout << "Cross Assignment via base pointers from type B objects to type A is forbidden" << endl;
      p00 = pA0;
      p01 = pB0;
      // A0 <-- B0, forbidden
      cout << "p00 is pointing to pA0 " << endl;
      *p00 = *p01;
      cout << "p00 is valid = " << p00->isValid() << endl;
      cout << endl;

      p00 = nullptr;
      p01 = nullptr;

      // "cross assignment": from A type to B type is allowed
      cout << "Cross Assignment via base pointers from type A objects to type B" << endl;
      cout << "is allowed by custom conversion... " << endl;
      p00 = pB1;
      p01 = pA1;
      // B1 <-- A1, custom conversion allowed
      cout << "p00 is pointing to pB1 " << endl;
      *p00 = *p01;
      cout << "p00 is valid = " << p00->isValid() << endl;
      cout << "p00 --> pB1 dataB = " << pB1->getDataB() << endl;
      cout << endl;

      p00 = nullptr;
      p01 = nullptr;

      delete pA0;
      delete pA1;
      delete pB0;
      delete pB1;
      cout << endl;
   }

   // we can deal directly with pointers to derived classes
   {
      CDerivedA* pA0 = new CDerivedA((double) 1.0);
      CDerivedA* pA1 = new CDerivedA((double) 2.0);
      CDerivedB* pB0 = new CDerivedB(string("This is B1"));
      CDerivedB* pB1 = new CDerivedB(string("This is B2"));
      cout << endl;

      // Assignment via pointers of type A objects
      cout << "Assignment via pointers of type A objects" << endl;
      // A0 <-- A1
      *pA0 = *pA1;
      cout << "pA0 dataA = " << pA0->getDataA() << endl;
      cout << "pA1 dataA = " << pA1->getDataA() << endl;
      cout << endl;

      // Assignment via pointers of type B objects
      cout << "Assignment via pointers of type B objects" << endl;
      // B0 <-- B1
      *pB0 = *pB1;
      cout << "pB0 dataB = " << pB0->getDataB() << endl;
      cout << "pB1 dataB = " << pB1->getDataB() << endl;
      cout << endl;

      delete pA0;
      delete pA1;
      delete pB0;
      delete pB1;
      cout << endl;
   }

   // of course we can deal also with base classes
   {
      cout << "Base class Assignment just works." << endl;
      CBase* p00 = nullptr;
      CBase* p01 = nullptr;
      p00 = new CBase((int) 10);
      p01 = new CBase((int) 11);
      *p00 = *p01;
      cout << "p00 is valid = " << p00->isValid() << endl;
      cout << "p00 data = " << p00->getData() << endl;
      cout << "p01 is valid = " << p01->isValid() << endl;
      cout << "p01 data = " << p01->getData() << endl;
      cout << endl;

      delete p00;
      cout << endl;

      cout << "Base class copy ctor just works." << endl;
      p00 = new CBase(*p01);
      cout << "p00 is valid = " << p00->isValid() << endl;
      cout << "p00 data = " << p00->getData() << endl;

      delete p00;
      delete p01;
      cout << endl;
   }

   // what about copy construction ?
   {
      // Copy ctor via pointers of type A objects
      cout << "Copy ctor via pointers of type A objects" << endl;
      CDerivedA* pA1 = new CDerivedA((double) 2.0);
      cout << endl;
      CDerivedA* pA2 = new CDerivedA(*pA1);
      cout << "pA1 dataA = " << pA1->getDataA() << endl;
      cout << "pA2 dataA = " << pA2->getDataA() << endl;
      delete pA1;
      delete pA2;
      cout << endl;

      // Copy ctor via pointers of type B objects
      cout << "Copy ctor via pointers of type B objects" << endl;
      CDerivedB* pB1 = new CDerivedB(string("This is B2"));
      cout << endl;
      CDerivedB* pB2 = new CDerivedB(*pB1);
      cout << "pB1 dataB = " << pB1->getDataB() << endl;
      cout << "pB2 dataB = " << pB2->getDataB() << endl;
      delete pB1;
      delete pB2;
      cout << endl;

      // Copy ctor via base pointers of type A,B objects
      cout << "Copy ctor via base pointers of type A,B objects" << endl;
      CBase* p00 = new CDerivedA((double) 1.0);
      CBase* p01 = new CDerivedB(string("This is B1"));
      cout << endl;

      cout << "A from A via base" << endl;
      CDerivedA* pA3 = new CDerivedA(*p00);
      cout << endl;
      cout << "base from A (slicing)" << endl;
      CBase*     pA4 = new CBase(*p00); // slice it
      cout << endl;

      cout << "B from B via base" << endl;
      CDerivedB* pB3 = new CDerivedB(*p01);
      cout << endl;
      cout << "base from B (slicing)" << endl;
      CBase*     pB4 = new CBase(*p01); // slice it
      cout << endl;

      cout << "A from B via base" << endl;
      CDerivedA* pA5 = new CDerivedA(*p01);
      cout << endl;

      cout << "B from A via base" << endl;
      CDerivedB* pB5 = new CDerivedB(*p00);
      cout << endl;

      delete pA3;
      delete pA4;
      delete pA5;

      delete pB3;
      delete pB4;
      delete pB5;

      delete p00;
      delete p01;

      cout << endl;
   }

   int k = getchar();
   return 0;
}

------- test program for both hierarchies -------------

Thanks in advance for any suggestion about why you would go with one instead of the other
(or, if eventually you do know a better idiomatic solution).

Federico

Re: Polymorphism & Assignment Op. & Copy Constructors in C++

Aescleal21-Oct-13 4:45

Aescleal

21-Oct-13 4:45

That looks like a shed load of code just to implement copying and assignment. Are you sure that copying objects of arbitrary types is both necessary to your design and won't turn into a complete millstone around your development team's neck? They might not thank you when they have to grind that lot out again to implement a new class? I'm also wincing at how the assignment operators are written - the canonical way you write an assignment operator in C++ is to use a copy and swap.

So... What would I suggest? Firstly go back to your design and see if it can be reworked to use a set of relatively simple principles:

- value types have no polymorphic behaviour and are copy constructable and assignable if appropriate. Use copy and swap to write the assignment operator for a value type

- polymorphic types are accessed through interfaces. Don't assign or copy the objects themselves, reference them through pointers or references to the interfaces they implement. The only place that knows the concrete type of a polymorphic type is the lump of code that creates the object

- don't use implementation inheritance. Containment gives far less headaches

- minimise manual memory management wherever possible. Use parameterise from above (PFA) and objects created on the stack wherever possible. If you write a delete statement pinch yourself and look at using std::unique_ptr or std::shared_ptr instead. RAII is your friend

- make everything exception safe but don't handle exceptions in too many places. One try/catch set in a function

If there's still a need to deep copy objects through pointers to arbitrary base classes then consider implementing a clonable interface. Never slice objects - once you lop off the context you can never get it back.

Re: Polymorphism & Assignment Op. & Copy Constructors in C++

federico.strati21-Oct-13 22:04

federico.strati

21-Oct-13 22:04

Thanks Aescleal,

all the techniques you suggest are fine, but my point was more on the discussion
of the copy ctor and assignment op. themselves: it is clear that if I make them
private, or if I just use the compiler generated ones for POD types, there will
be no worry.

By the way what do you mean exactly by "copy and swap" ? Do you mean this ? :

C++

Object& operator = (const Object& other)
{
   Object(other).swap(*this);
   return *this;
}

(How do you ensure no self assignment in this case ?, by forwarding to std::swap ?)

My point anyway was about how to do in the correct way when I've a hierarchy,
I've deep copies, I've to be able to use base class pointers or derived pointers:
i.e. in the most general case.

In this general case it seems to me that you're forced to use one of the given approaches,
and that you shall handle all cases of copy ctor and assignment ops explicitly
(derived from derived, derived from base, base from derived, base from base)
maybe just disallowing some of them.

Just to be clear, my point is the following:

C++

CBase* pbase0 = new CDerived(...);
CBase* pbase1 = new CDerived(...);

*pbase0 = *pbase1 // Will it works correctly or will it slice and I should disallow it ?

Bye
Federico

modified 22-Oct-13 4:44am.

Re: Polymorphism & Assignment Op. & Copy Constructors in C++

Aescleal21-Oct-13 23:15

Aescleal

21-Oct-13 23:15

Generally: Deep hierarchies (i.e. anything more than inheriting an interface) are bad news. Implementation inheritance is the strongest coupling there is and you'll end up with fragile logical designs (you'll spend ages trying to work out what goes where in your class taxonomy and find you have to shuffle a lot of members around) and long build times (when you shuffle you'll have to rebuild the world). If you stick to parameterise from above and interface inheritance you won't have to copy objects, just references and the whole question becomes moot.

Copy and swap is:

C++

T &T::operator=( const T &t )
{
    T temp( t );
    swap( temp );
    return *this;
}

where swap is non-throwing. You get exception safety for free and if you use the PIMPL idiom and lean on std::unique_ptr it's pretty trivial to implement.

Re: Polymorphism & Assignment Op. & Copy Constructors in C++

federico.strati22-Oct-13 0:12

federico.strati

22-Oct-13 0:12

Hello Aesclal,

thanks again, may I ask you (if you got the time) to append some links
in order to let other readers as well understand the topic ?

(e.g. spelling out what is PFA - parameterise from above - and its coupling with interface
inheritance, why you will then work only with references, etc...).

The best would be a link to a public domain example...

About "swap", I left it out first from my discussion in order to focus only on copy ctor
& assignment operators, otherwise you should add also the swap method to the examples.

Anyway, usually I would add this to the assignment op:

C++

T &T::operator=( const T &t )
{
    if ( this != &t ) // self assignment, you may also think of using address-of to be safer
    {
       T temp( t );
       swap( temp );
    }
    return *this;
}

The PIMPL idiom (for the sake of other readers) is the private implementation idiom.

Bye
Federico

SQLFetchScroll is failing if database column contains NULL value

Ashish Ranjan Mishra14-Oct-13 21:13

Ashish Ranjan Mishra

14-Oct-13 21:13

HI,
I am using SQLFetchScroll for bulk reading from DB .But it is failing for some tables loading where columns contain NULL values.
Can anyone help me on this to get rid of this?

Regards,
ASH

asdsa

Re: SQLFetchScroll is failing if database column contains NULL value

Rajesh R Subramanian14-Oct-13 22:24

Re: SQLFetchScroll is failing if database column contains NULL value

14-Oct-13 22:24

Have you checked the return value to see how it's different from when it succeeds?

Have you seen the diagnostics information provided in the documentation page[^]?

"Real men drive manual transmission" - Rajesh.

Ashish Ranjan Mishra14-Oct-13 23:24

Ashish Ranjan Mishra

14-Oct-13 23:24

Yes, Rajesh I have checked the return code is -11072.. I am not able to find any related document for this error code

Any help is appreciate..

Thanks,
Ashish

asdsa

Re: SQLFetchScroll is failing if database column contains NULL value

Rajesh R Subramanian14-Oct-13 23:29