OOP Newbie

[Joe101]

Hello, I'm a complete newb to C++ and am trying to adapt/adjust my Java thinking to this new language.

I'm a bit confused by the differences between the following code snippets which each refer to an object myA that is an instance of the Class Apple that has a method doSomething


A) myA.doSomething();
B) myA->doSommething();
C) myA ::doSomething();

What is the difference between these three lines. Some of these snippets are probably completely wrong!

[Bazzy]

myA.doSomething() myA is an object of a class and doSomething is a method called from that object

myA->doSommething myA is a pointer to a class object and doSomething is a method called from the object pointed by myA

myA::doSomething() myA is a namespace and doSomething is a function from that namespace or myA is a class an doSomething is a static function of that class

[andrei c]

Hello Joe!
Well, the first 2 methods, A and B, refer to accessing the variables or functions inside a class.
For example:

class Car
{
   public:
   Car(string Name, int Max_speed, int Color); // constructor
   ~Car() {};  // deconstructor
   string name; // the name of the car
   int max_speed; // the max speed
   int color; // the color of the car
   void start_engine(); // function that starts the engine
   void stop_engine(); // function that stops the engine
}

Now if you make objects of type car:

Car Volvo( "Volvo", 120, 0); // this is a statically allocated object
Volvo.start_engine(); // because it is staticcaly allocated you use the '.' operator to refer to its variables or functions

Car *Renault = new Car( "Renault", 120, 2); // this is dinamically allocated object
Renault->start_engine(); // because it is dinamically alocated you use the '->' operator instead, to refer to properties or methods 

The third option, C, refers to the scope operator :: and has to do with namespace.
For example let's say you want to define the 4 methods inside the class:

class Car
{
   public:
   Car(string Name, int Max_speed, int Color); // constructor
   ~Car() {};  // deconstructor

   string name; // the name of the car
   int max_speed; // the max speed
   int color; // the color of the car
   void start_engine(); // function that starts the engine
   void stop_engine(); // function that stops the engine
}

Car::Car(string Name, int Max_speed, int Color)
{
   name = Name;
   max_speed = Max_speed;
   color = Color;
}

void Car::start_engine() // you use the scope operator to specify that the function is from a certain class
{
   //whatever source code
}

void Car::stop_engine()
{
   //whatever source code
}

As you can see, you use the scope operator to tell the compiler from wich class that function is, in case you have the same name of functions in 2 or more classes and you want to be able to still differentiate between functions.Like bellow:

class Car
{
   string name;
   int max_speed;
   void start_engine();
   void stop_engine();
}

class Plane
{
   string name;
   int max_speed;
   void start_engine();
   void stop_engine(); // be carefull with this one :)
}

void Car::start_engine() // this is the start_engine() function from the Car class
{
   //whatever source code
}

void Plane::start_engine() // this is the start_engine() function from the Plane class
{
   //whatever source code
}

So remember:
. and -> are for accessing properties or method of a class (or object of that type)
:: is to specify from what class or namespace (you could just have a namespace) is that variable or function from.

[Joe101]

thank you!