Passing Pointer To Class In A Function

Hey guys just another is this the right way to do it question.
I like to make sure im doing it right even if it seems to work :)

Code:

---

#include <iostream>
class loser
{
  public:
    int loserPower;
};

void modifyingLoser(loser *mLoser);
int main()
{
  loser me;
  loser *ptrMe;
  ptrMe=&me;
  modifyingLoser(ptrMe);
  std::cout<<ptrMe->loserPower;
  getchar();
  return 0;
}
void modifyingLoser(loser *mLoser)
{
    mLoser->loserPower=10;
}

---

Thanks as Always :)

All looks good to me.

Ok, thank you zach

It's easier to do this, but perhaps you need the pointer for some reason.

Code:

---

  modifyingLoser(&me);
  std::cout<<me.loserPower;

---

Another thing to consider, if you aren't wedded to the current version, is to make modifyingLoser() a public mutator method of the loser class and changing access of loserPower to private instead of public to protect it from unwanted changing by non-class functions.

Quote:

---

Originally Posted by swoopy

It's easier to do this, but perhaps you need the pointer for some reason.

Code:

---

  modifyingLoser(&me);
  std::cout<<me.loserPower;

---

---

Thank you swoopy that is much easier :)

Oowie, something that I was having trouble with.
I don't understand what the "->" operator does in classes/structures. Is it a balance of a condition, operator, or a statement and what does it do? Does it do anything related to the misunderstood "." operator? Or, does it have to do with pointers hence ("int x->e;" == "int * x = &e)?

The arrow operator dereferences and accesses pointers. For example:

Code:

---

struct foo {
  int bar;
};

int main( )
{
  foo* ptr = new foo;
  // The following lines are equivalent.
  ptr->bar = 5;
  (*ptr).bar = 5;
}

---

I hope it won't confuse you, but in C++, other than C, you must not use pointer for function parameters you want to change. Instead better use reference-parameters wherever you can. :)

Code:

---

#include <iostream>
class loser
{
  public:
    int loserPower;
};

void modifyingLoser(loser& mLoser);
int main()
{
  loser me;
  modifyingLoser(me);
  std::cout<<me.loserPower;
  getchar();
  return 0;
}

void modifyingLoser(loser& mLoser)
{
    mLoser.loserPower=10;
}

---

mfg JJ

I guess its really a matter of taste because in the end its the same result as this

Code:

---

#include <iostream>
class loser
{
  public:
    int loserPower;
};

void modifyingLoser(loser *mLoser);
int main()
{
  loser me;
  modifyingLoser(&me);
  std::cout<<me.loserPower;
  getchar();
  return 0;
}

void modifyingLoser(loser *mLoser)
{
    mLoser->loserPower=10;
}

---

I Think the -> is cooler loooking :)

It would be better to initialize your loserPower integer before you work with it.

I generally pass a pointer only if the object I am dealing with could be NULL, I know that in the rest of my code I will be dealing with pointers rather than the objects themselves, or I'm going to need to cast up from a base class to do something specific to whatever derived class I happen to have passed (which is rare, and generally done away with through the use of virtual functions, but not always -- and it is more pleasant to check to see if a pointer is NULL, than catch an exception). Other than that, there is less you can accidently do with a reference.