C / C++ / MFC

class classComponent; // Forward reference to implementation class.
 
class MyClass
{
public:
    MyClass();
    ~MyClass();
    void DoStuff();
 
private:
    classComponent *m_pThis;
};

#include "classComponent.h" // Include header of implementation class here.
 
MyClass::MyClass()
{
	m_pThis = new classComponent;
}
 
MyClass::~MyClass()
{
	delete m_pThis;
}
 
void MyClass::DoStuff()
{
	m_pThis->DoStuff();
}

marcelcerdanjunior wrote:

How can I "mask" the dependendancies on classComponent for the final user ?

marcelcerdanjunior wrote:

I want that the user of MyClass.h doesn't need to have access to all other includes files like classComponent.h

T * a = new T [xdim * ydim];
if (! a ) return false;

T ** m = new T * [xdim];
if (! m)
{
  delete [] a;
  return false;
}
for (i = 0; i < xdim; i++)
{
  m[i] = a + i * ydim ;
}
return true;

Member 4655885 wrote:

is it equivalent to:?

Cedric Moonen wrote:

you linked to the post which is just above yours

CPallini wrote:

But, as already admitted, my post was clumsy...

Randor wrote:

But just imagine how funny it would have been if Iain edited his post and added a link back to your post

*M = new T* [xdim];

**M = new T [xdim*ydim];

if (*M==NULL || **M==NULL)
   return false;

for(int i=1; i < xdim; i++)
  (*M)[i] = (*M)[i-1] + ydim;

M **My2DArray;
if (!AllocateUsingTooMuchCleverness (&M))
   return ....

delete [] **M;
delete [] *M;

*M = new T* [xdim]; **M = new T [xdim*ydim];
if (*M==NULL || **M==NULL) return false;
for(int i=1; i < xdim; i++)
(*M)[i] = (*M)[i-1] + ydim;

void function (int xdim, int ydim)
{
   int **M   

   M = new int * [xdim]; // M now points to an array of int *'s. They point to junk at the moment.
   // M[0] is the first pointer in that array - M[1] is 2nd - but none of them point anywhere yet.
   if (M == NULL) return;   // checking error in the right place...

   //*M = new int [xdim * ydim]; is equivalent to...
   M [0] = new int [xdim * ydim];  // so, we've allocated a big lump of continuous ram, ready to be filled with ints. and M[0] points to the beginning.
   if (M[0] == NULL)
   {
      delete [] M;  // use the [], as T might be a type with a destructor
      return;
   }

   for(int i=1; i < xdim; i++)
      M [i] = M[i-1] + ydim;