Thread: Calling class member

Another quick question guys. Say I have a class eg.

Code:

class person
{
 public:   
    void goToBathRoom();
    void poop();
    void pee();
};

void person :: goToBathRoom()
{
    cout<<"What do you want to do [1]Poop [2]Pee"<<endl;
    int poopOrPee;
    cin>>poopOrPee;
    switch(poopOrPee)
    {
      case 1:
      //This is my question
      poop();
      //is this ok it seems to work 
      person::poop();
      //or is it this?
      break;
      case 2:
      pee();
      person::pee();
      break;
     }
}

Thanks as always

ok just making sure didn't want to mess things up

>>calling Object::function() should only be done if 'function' is static.
Even then you don't need to, since calling (an object).(static member function)() is the same as calling (class):static member function)().

The only time when you'd really need to call Classname::function() would be when the function is overloaded in a derived class and you want to call the function from the base class.

Code:

class A
{
public:
   void pee() {cout << "Now peeing...\n";}
};
 
class B : public A
{
public:
   void pee() {cout << "Peeing has commenced...\n";}
   void poo() {cout << "Now pooing...\n"; A::pee();} //Calls base class' version
};

what exactly is, " this-> " I have heard it before.. but I am not familiar with this somewhat abstract idea..

if someone could break this-> down to the 1st grade level.. that would be wicked awesome.

Here is my bad programming humor for the day.

Code:

class person
{
 public:   
    void goToBathRoom();
    void poop();
    void pee();

Q: shouldn't void poop() and void pee() return objects ?

ha.

>>Q: shouldn't void poop() and void pee() return objects ?
It could, but you're voiding yourself of your feces and urine.

>>what exactly is, " this-> "
The keyword 'this' gives a pointer to the object that it's in. For example:

Code:

Person* Person::getPointerToTheObject()
{
   return this;
}
 
int main()
{
   Person p;
   Person* ptr1;
   Person* ptr2;
   ptr1 = &p;
   ptr2 = p.getPointerToTheObject();
 
   return 0;
}

In this example, both ptr1 and ptr2 will contain valid pointers to the Person object called 'p'. I believe that's how cout works; its operator<< () is defined to return an ostream&, so what it does is:
1. Output whatever came after the <<
2. Return (*this) (this returns a pointer to itself; so de-reference the pointer and it returns itself).

That's why you can chain together a bunch of <<:

Code:

((((cout << "Hello! My name is ") << name) << " and I am ") << age) << "years old!";

cout << "Hello! My name is " returns cout, so the next step is cout << name, which returns cout, etc. and you get a nice chain reaction type thing going on

And to answer your question:
pointer->something()
is the same as
(*pointer).something()

So in short, -> is a shortcut that we use because we're lazy. Also, you can overload the -> operator, but that's not done very often so you probably don't need to worry about it. Putting it all together, this->doSomething() is basically saying (this current object).doSomething().

awesome. understand completely. excellent example. (sorry for the long time to reply)

oh I forgot to ask... is it possible to dereferrence "this" (i.e. this->gotothebathroom( ) ) as pointer to 'class person'..?? or will "this" only return a 'person' pointer...

got it now.. thanks for your help


another tool to add to my intermediate c++ repitior.


I hope I spelled, "repitior" right...

I think the only question I have left is.. any reason to use this instead of returning your own pointer to the object..?

>>any reason to use this instead of returning your own pointer to the object..?
Yes. For example, if you have a member function which adds a pointer of the object to a static class array for internal use:

Code:

class MyClass
{
public:
   MyClass() {IndexMyself();}
   ~MyClass() {UnIndexMyself();}
   void DoSomething();
   void DoSomethingElse(); //or whatever
   static void DoSomethingToAllObjectsEverCreated();
 
protected:
   void IndexMyself();
   void UnIndexMyself();
   static std::set<MyClass*> allObjects;
};
 
 
void MyClass::IndexMyself()
{
   allObjects.insert(this);
}
 
void MyClass::UnIndexMyself()
{
   allObjects.erase(allObjects.find(this));
}
 
void MyClass::doSomethingToAllObjectsEverCreated()
{
   for(std::set<MyClass*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
   {
	  //do something to each object
   }
}

It would be hard to do something like that without the use of this. Of course, you could store the pointers in your own array and write your own function and blah blah blah, but that's just an example of something you could do using this (make the class more of an automatic thing)

**EDIT**
Also, like I said... without returning this, you wouldn't be able to chain together a bunch of << with cout. And that's another good reason to use this

**EDIT2**
!@#$%!^% I hate these edit boxes!!! Why does it always screw up my code???