Odniesienie do konstruktora (c++)

Question

Witam napisałem mały program, którego sens nie ma wielkiego znaczenie, zależy mi na tym aby funkcja odnosiła się do elementów kontruktora.

#ifndef P1_H_
#define P1_H_

#include <string>
class Prosba
{
        private:
                std::string slowo;
                double energia;
        public:
                void show_elements(std::string zdanie, double moc);
        Prosba(); 
};
#endif

#include "p1.h"
#include <iostream>
Prosba::Prosba() {
        std::cout << "Podaj nazwe: "; std::cin >> slowo;
        std::cout << "Moc: "; std::cin >> energia;
        ((energia >= 33.2) ? std::cout << "Masz moc Thanosa!\n" : std::cout << "HULK sie boi!\n"); 
}

void show_elements(std::string zdanie, double moc)
{ std::cout << zdanie << ": " << moc << "\n\n"; }
int main()
{ Prosba marka;  show_elements(Prosba::slowo, Prosba::energia); return 0; }

Chcę zrobić tak aby 'show_elements' wyświetlało to co zostanie wpiszane przez obiekt 'marka'

Answer 1

To co spróbowałeś zrobić:

Prosba::slowo

zaprzecza temu co napisałeś wcześniej:

private:

Jak prywatne to prywatne i nie można się do nich odwołać spoza klasy.

Co do pytania: jest sporo możliwości.
1. Niech show_elements będzie funkcją składową (metodą) klasy Prośba, wtedy po prostu wypisujesz składowe prywatne, łatwizna. U Ciebie jest to po części zrobione, bo jest deklaracja show_elements w klasie, ale później dostarczona definicja nie odwołuje się do show_elements z klasy tylko definiuje zwykłą wolną funkcję show_elements. Możliwe, że zapomniałeś dodać operatora zakresu:

void Prosba::show_elements(std::string zdanie, double moc)

I wtedy ta nie funkcja a metoda nie będzie już musiała pobierać argumentów, bo ma ona normalny dostęp do składowych obiektu:

void Prosba::show_elements()

Jest to najbardziej obiektowe podejście. Bo kwintesencja programowania obiektowego to połączenie stanu oraz zachowania danych.

Jeśli jednak nie może być częścią klasy Prośba to:
2. Najbardziej standardowe podejście: gettery. Składowe słowo oraz energia są prywatne, więc żeby się do nich odwołać robi się publiczne metody, które je zwracają:

	std::string getSlowo() { return slowo; }
	double getEnergia() { return energia; }

a wtedy wywolanie show_elements będzie wyglądało tak:
 

show_elements(marka.getSlowo(), marka.getEnergia)

Ostatnie trochę na siłę, nie używaj. Chce tylko pokazać, że jest jeszcze jeden sposób odwołania do prywatnych zmiennych.
3. Można użyć deklaracji przyjaźni pomiędzy normalną globalną funkcją show_elements a klasą. Wtedy będzie ona miała dostęp do składowych prywatnych funkcji. Wtedy przesyłałbyś obiekt klasy Prosba w argumencie. W klasie Prosba deklaracja przyjazni z funkcją:
 

friend void show_elements(const Prosba& prosba);

i definicja tejże funkcji poza klasą:
 

void show_elements(const Prosba& prosba)
{
	std::cout << prosba.slowo << ": " << prosba.energia << "\n\n";
}

 

Answer 2

class Prosba
{
        private:
                std::string slowo;
                double energia;
        public:
                void show_elements();
        Prosba(); 
};

void show_elements()
{ 
    std::cout << slowo << ": " << energia << "\n\n"; 
}

int main()
{ 
    Prosba marka;  
    marka.show_elements(); 
    return 0; 
}

 

Comments

void Prosba::show_elements() {....}