How can I access the private members of my class?

Question

#include <iostream>

class Army{
   int units;
   double power;

public:
   int get_units(){
       return units;
   }
   void createarmy(int troops,double pow) {
       units = troops;
       power = pow;
   }
}

void display(Army* armies,int size)
    // How can i make this function to get all the values at
    // armies[0] and at armies[1]?
}

int main(){
    Army armies[2]{};
    armies[0].createarmy(100,500);
    armies[1].createarmy(180,400);

    display(armies,2);
}

Answer 1

How can I make this function to get all the values at armies[0] and at armies[1] using a pointer

While there are ways to access private members of a class from outside that class - let us instead give more thought to whether you should really be facing this problem.

You, or whoever designed the Army class, decided that an army's units member is (read-only) accessible, with the get_units() method; but that its power is not accessible, i.e. it is an implementation detail which should not be relevant from the outside.

Does this make sense? Your question suggests that the answer is negative: You want to "display an army's characteristics", including its power. That means the power is not an implementation detail, and is relevant to the outside.

Assuming I'm right, what you probably want to do is simply add a similar getter method for power as the one you have for units:

class Army {

   // etc. etc.

   double get_power() { return power; }

   // etc. etc.
};

Additional notes:

• Both these getter methods can be marked as const - since they don't alter the state of the Army object. Thus,

  double get_units() const { return units; }
  double get_power() const { return power; }
  

• Instead of repeating the type of your members whenever you work with them, you might want to define an Army::size_type and a Army::power_type; or these might be type definitions outside your class.

• Let's hope these armies stay in games and we are spared their power and units in real life.

• The display() function should not be able to modify armies, so better make it void display(const Army* armies, int size).

• display() is not a great choice for a function name; it's a bit ambiguous; I'd choose something like void list_statistics(const Army* armies, int size).

• Don't pass a sequence of elements in memory the old C-style way: A pointer and a size. Instead, pass them in an std::span:

  void list_statistics(std::span<const Army> armies)
  {
     for(const Army& army : armies) {
       // code for "displaying" a single army
     }
  }