Klasy - wywoływanie konstruktora

0

mam taką klasę

class golf
{
	private:
		std::string fullname;
		int handicap;
	public:
		golf();
		golf(const std::string & ln = "", const int hc = 0);
		
		golf setgolf();		
};

oraz metody i konstruktory

golf::golf()
{
	fullname = "brak nazwy";
	handicap = 0;
}

golf::golf(const std::string & ln, const int hc)
{
	fullname = ln;
	handicap = hc;
}

void golf::setgolf()
{
	std::cout << "Podaj Nazwisko: ";
	std::cin >> fullname;
	
	std::cout << "Podaj Handicap: ";
	std::cin >> handicap;
}

metoda set golf ma pobierać dane interaktywnie, te dane mam przekazać do wywołania konstruktora obiektu tymczasowego i przypisać ten obiekt do obiektu wywołującego *this.
Prosiłbym o pomoc z tym.

0

to się przecież nie kompiluję...

masz dwa konstruktory domyślne. Masz poplątana deklaracje z definicją.

Domyślam się że chodzi o coś takiego (co jest bezsensu)

{
        std::cout << "Podaj Nazwisko: ";
        std::cin >> fullname;

        std::cout << "Podaj Handicap: ";
        std::cin >> handicap;

        return golf(fullname,handicap);
} 
    golf obiekt;
    obiekt = obiekt.setgolf(); 
0
class golf
  {
   private:
   std::string fullname;
   int handicap;
   public:
   golf(const std::string &fullname="brak nazwy",int handicap=0);
   golf(std::istream &sin,bool Ask=true);
  };

golf::golf(const std::string &fullname,int handicap),fullname(fullname),handicap(handicap)
  {
  }
 
golf::golf(std::istream &sin,bool Ask)
  {
   if(Ask) std::cout<<"Podaj Nazwisko: ";
   sin>>fullname; 
   if(Ask) std::cout<<"Podaj Handicap: ";
   sin>>handicap;
  }

// wywołanie:
golf G(cin);
golf Zpliku(ifstream("plik.txt"),false);
0

a użycie wskaźnika *this nie jest potrzebne ??

0

mam jeszcze takie pytanie, metoda tworząca obiekt oraz go inicjalizująca.
O co z tym chodzi??

0
Kosimazaki123 napisał(a):

mam jeszcze takie pytanie, metoda tworząca obiekt oraz go inicjalizująca.
O co z tym chodzi??

Pewnie metoda zwracająca nowy obiekt, który inicjalizujesz przy pomocy konstruktora/setterów.

0

ale to muszę zrobić takie coś

<code class="cpp">dom x1;
x1 = x1.nowy_obiekt();

gdzie dom no nazwa clasy a nowy_obiekt to metoda,
dom x1 tworzy obiekt i inicjalizacje go konstruktorem, więc poco takie udziwnienia w metodzie??

np takie coś

class Move
{
	private:
		double x;
		double y;
	public:
		Move(double a=0, double b=0);
		void showmove() const;
		Move Move_add(const Move & m) const;
		void reset(double a=0, double b=0);
};
#include <iostream>
#include <cstring>
#include "classdeclaration.h"

Move::Move(double a, double b)
{
	x = a;
	y = b;
}

Move Move::Move_add(const Move & m) const
{
	double c, d;	
	c = x + m.x;
	d = y + m.y;
	
	return Move(c, d);
}

void Move::reset(double a, double b)
{
	x = a;
	y = b;
}

void Move::showmove() const
{
	std::cout << "x: " << x << "    " << "y: " << y << std::endl;
}
#include <iostream>
#include "classdeclaration.h"
#include "metody.cpp"

int main(void)
{
	Move x(5, 2);
	Move y(1, 6);
	
	x = x.Move_add(y);
	x.showmove();
		
	return 0;
}

metoda Move_add tworzy nowy obiekt, inicjalizacje go i zwraca??

0

robi się to tak:

dom x1; // konstruktor
x1.init(); // metoda inicjalizująca (nazwa i parametry dowolne)

a po co?

Na przykład, jeśli inicjalizacja obiektu może się nie powieźć, możemy przenieść ją z konstruktora do metody, z której to metody można zwrócić boola albo kod błędu. W konstruktorze jedyne co możemy zrobić to wywalić wyjątek, a tego możemy nie chcieć z innych powodów.

Albo jeśli obiekt jest "ciężki", może się opłacać użyć tego samego obiektu kilka razy w różnym celu:

dom x1; // załóżmy, że tu jest alokacja dużej ilości pamięci, albo połączenie sieciowe...
x1.init();
...
x1.init(); // wyzerowanie obiektu, unikające ponownej alokacji pamięci.
...
0

nic z tego nie rozumiem, a w tym przykładzie to dobrze zrobiłem??

0
Kosimazaki123 napisał(a):

nic z tego nie rozumiem, a w tym przykładzie to dobrze zrobiłem??

Sam sobie odpowiedz, można to zapisać tak:

Move Move::Move_add(const Move &m) const
  {
   return Move(x+m.x,y+m.y);
  }

Ale do takiego zadania bardziej potrzebujesz:

Move &Move::add(const Move &m)
  {
   x+=m.x;
   y+=m.y;
   return *this;
  }

Z wywołaniem:

x.add(y).showmove();
0
Move &Move::add(const Move &m)
  {
   x+=m.x;
   y+=m.y;
   return *this;
  }

ale to zwraca obiekt w którym, obecnie wykonywana jest operacja, czyli nie tworzy nic nowego.

Move Move::Move_add(const Move &m) const
  {
   return Move(x+m.x,y+m.y);
  }

A to poprzez wywołanie konstruktora w instrukcji return tworzy nowy obiekt, czyli to chyba lepiej pasuje.

1 użytkowników online, w tym zalogowanych: 0, gości: 1