C / C++ / MFC

GoToCellDialog::GoToCellDialog(QWidget *parent)
{
  QDialog(parent); // Call parent constructor
  ... // rest of initialisation
}

class A
{
  int a;

  int func()
  {
    // Because we are inside class A, this refers to the current instance of A when func is called
    // Therefore, the following two lines are equivalent:
    return this->a; 
    return a;
  }
};

class B : A
{
  int b;

  int funcB()
  {
    // Again equivalent are:
    return this->b;
    return b;
    // Now this actually refers to an instance of object B, but because B is derived from A
    // we also have access to a, so also equivalent are:
    return this->a;
    return a;
  }
}

int main()
{
  // 'this' does not exist here, because main is not part of a class
}

class C
{
  int c;
  static sc;

  static int funcC()
  {
    // Here, becaus funcC is static (so it does not belong to an instance of a class)
    // 'this' doesn't exist either. So, you could write:
    return sc;
    // But you could not write:
    return this->sc; //Error: this does not exist in a static function
    return this->c; // This also produces an error
  }
}

Abder_Rahman wrote:

...I specifically just want to now what this refers to.

COleDateTime dt(*(vargValue.pdate));

// file A.h
class TEST {
public: // <-- you need this if you want to directly access num elsewhere (not a good style, but thats another problem)
   TEST(); // you said you initialized num in constructor, so you must have this!
   int num;
   void fun();
}
// you said the code that creates your TEST object is in A.cpp, but since you normally don't
// create an object of a class type from within that class I added a function to do that below
TEST* createTest();
// since I added a Creator, I added the appropriate destructor as well here:
void destroyTest(TEST* pObj);  

// file A.cpp
#include "A.h"
TEST::TEST() : num(0) {} // constructor initializes num with 0
void TEST::fun() {}
TEST* createTest() {
  TEST* pObj = new TEST();
  pObj->num++;
  return pObj; // this makes sure you can access the new object from elsewhere
}
void destroyTest(TEST* pObj) { // this is needed to properly destroy the object again!
   delete pObj;
}

// file Sample.cpp
#include "A.h"
void theUnknownFunction(TEST* p) { // pass your object as a parameter like this
   int mynumber = p->num; // read num from object
}

// file main.cpp
#include "A.h"
void theUnknownFunction(TEST* p); // it would be better to put this in a header file!

int main() {
   TEST* pObj = createTest();
   theUnknownFunction(pObj); // now you pass the object that you created to your function in sample.cpp
   destroyTest(pObj); // don't forget to clean up again
}

yogeshs wrote:

//CPP file A.cpp
/*In this class I want to create a Pointer of object in some function*/
TEST* _pObj = new TEST();
_pObj->num++;//num already initialize in constructor.

//This will allow you to access that member at any point in Sample.cpp
#include "A.h"

class CSample
{
  public:
   CSample(){m_obj = new TEST;} //Initialize m_obj
   ~CSample(){delete m_obj;}    //Delete to free heap memory

  private:
   TEST* m_obj;                 //Members are accessible anywhere in the class
};