Zwrócenie wektora obiektów

0

Cześć mam następujący problem:

  1. Stworzyłem klasę Punkt, z polami x, y.
  2. Stworzyłem klasę abstrakcyjna AbsCFigura, w której stworzyłem vector obiektów Punkt
    (tutaj pojawił mi się już pierwszy problem nie wiem czy istnieje taka możliwość aby z góry narzucić iż rozmiar vectora ma rozmiar 4, taka konstrukcja: vector<CPunkt> wierzcholki(4) wywala mi błąd.
    Wiem, że można narzucić rozmiar za pomocą metody resize(4) ale czy da się to zrobić odrazy przy tworzeniu vektora obiektów?
    3.W klasie AbsCFigura zadeklarowałem metodę wirtualną virtual void setWierzcholki() = 0; dzięki, której w klasach potomnych chce ustawiać wartosci wspolrzednych punktów określających wierzchołki danej figury(czworokąta). W zależności od tego jaka to będzie figura wykorzystam jej własności.
    4.W klasie abstrakcyjnej stworzyłem metodę virtualną, która ma za zadanie obliczać obwód danej figury.

Troche się w tym wszystkim zakopałem i chciałbym jakoś przekazac do funkcji ObliczObwod wektor z 4 punktami i przypuszczam ze aby to zrobić musze zrobić gettera, który będzie zwracał mi tablice obiektów i tutaj mam główny problem.
Dodatkowo chciałbym wiedzieć czy można zrobić coś takiego, że tworze tablice obiektów w klasie abstrakcyjnej i wszystkie klasy dziedziczące są wyposażone w tą tablice tj. Przykładowo stworze sobie klasę trapez i chciałbym, żeby ona była już wyposażona w tablice obiektow(4 wierzcholkow) tak zebym nie musial po raz kolejny w sekcji prywatnej tej klasy znowu tworzyć nowej deklaracji. Jeżeli tak się nie da to wychodziłoby na to ze dla każdej klasy dziedziczącej po klasie AbsCFigura trzeba tworzyć oddzielna tablice obiektów do przechowywania współrzędnych wierzchołków..
Pewnie napisałem trochę zawiło ale mam nadzieje, że ktoś załapie o co mi chodzi a jeżeli nie to proszę zadać mi pytanie w razie wątpliwości to postaram się bardziej doprecyzować :)

KOD:
Plik Punkt.h:

 #pragma once
class CPunkt
{
	int x, y;
public:
	CPunkt();
	CPunkt(int X, int Y);
	~CPunkt();

	//setters
	void setX(int X);
	void setY(int Y);

	//getters:
	int getX();
	int getY();
};

Plik Punkt.cpp:

#include "Punkt.h"


CPunkt::CPunkt(){}
CPunkt::CPunkt(int X, int Y){
	x = X;
	y = Y;
}

CPunkt::~CPunkt(){}

//setters
void CPunkt::setX(int X){
	x = X;
}
void CPunkt::setY(int Y){
	y = Y;
}

//getters:
int CPunkt::getX(){
	return x;
}
int CPunkt::getY(){
	return y;
} 

AbsCFigura.h:

 #pragma once
#include "Punkt.h"
#include<vector>
#include<iostream>
using namespace std;


class AbsCFigura
{
    vector<CPunkt> wierzcholki;
	//CPunkt wierzcholki[4];

public:
	AbsCFigura(vector<CPunkt> Wierzcholki);

	vector<CPunkt>& getWierzcholki();


	//methods
	

	//virtual methods:
	virtual void setWierzcholki() = 0;
	virtual double ObliczObwod(vector<CPunkt> wierzcholki) = 0;


};

AbsCFigura.cpp:

#include "AbsCFigura.h"
#include<iostream>
#include<cmath>
using namespace std;

AbsCFigura::AbsCFigura(vector<CPunkt> Wierzcholki){
	Wierzcholki.resize(4);
	wierzcholki.resize(4);
	for (int i= 0; i < 4; i++)
	{
		this->wierzcholki[i] = Wierzcholki[i];
	}
}

//vector<CPunkt>& getWierzcholki(){
//
//	return 
//} 

Kwadrat.h:

#pragma once
#include "AbsCFigura.h"
#include "Punkt.h"
#include<vector>
#include<iostream>
using namespace std;

class CKwadrat :
	public AbsCFigura
{
	//CPunkt wierzcholki[4];
	vector<CPunkt> wierzcholki;
	int a;
public:
	CKwadrat();
	CKwadrat(int A);
	~CKwadrat();

	//setters
	void setA(int A);	

	//getters
	int getA();

	//virtual methods:
	void setWierzcholki();
	//double ObliczObwod(int A);
	double ObliczObwod(vector<CPunkt> wierzcholki);

}; 

Kwadrat.cpp:

#include "Kwadrat.h"
#include "AbsCFigura.h"
#include "Punkt.h"
#include<iostream>
using namespace std;

CKwadrat::CKwadrat() : AbsCFigura(wierzcholki){}
CKwadrat::CKwadrat(int A) : AbsCFigura(wierzcholki)
{
	a = A;
}

CKwadrat::~CKwadrat(){}

//setters
void CKwadrat::setA(int A){
	a = A;
}

//getters
int CKwadrat::getA(){
	return a;
}

//virtual methods:
void CKwadrat::setWierzcholki(){
	cout << "Podaj dlugosc boku kwadrata:" << endl;
	int A;
	cin >> A;
	setA(A);

	cout << "Podaj wspolrzedne punktu bazowego kwadratu:" << endl;
	int x, y;
	cin >> x;
	cin >> y;

	//wierzcholek bazowy:
	wierzcholki[0].setX(x);
	wierzcholki[0].setY(y);

	wierzcholki[1].setX(x + a);
	wierzcholki[1].setY(y);

	wierzcholki[2].setX(x);
	wierzcholki[2].setY(y + a);

	//przeciwlegly wierzcholek kwadrata:
	wierzcholki[3].setX(x + a);
	wierzcholki[3].setX(y + a);
	
}

double ObliczObwod(vector<CPunkt> wierzcholki)
{
//uniwersalna metoda do obliczania owbodu kazdego
//na podstawie tw. Pitagorasa
	return 0;
}

//double ObliczObwod(int A)
//{
//	return 4*A;
//} 

Source.cpp:

#include<iostream>
#include<vector>
#include<cmath>
#include"AbsCFigura.h"
#include"Kwadrat.h"
#include"Punkt.h"

using namespace std;

int main()
{
	CKwadrat abc;
	abc.setWierzcholki();
	//abc.ObliczObwod();


	return 0;
}
0

Dodatkowo chciałbym wiedzieć czy można zrobić coś takiego, że tworze tablice obiektów w klasie abstrakcyjnej i wszystkie klasy dziedziczące są wyposażone w tą tablice
Tak.

1

To co mi wpadło na pierwszy rzut zaspanego oka :-)

  1. Po co Ci (teraz) destruktor w CPunkt? W klasie nie ma atrybutów co do których jest konieczność kontrolowanego niszczenia. Podobnie w CKwadrat.

  2. Atrybut wierzchoki z klasy AbsCFigura, zainicjuj przez listę inicjalizacyjną (AbsCFigura.cpp):

...
AbsCFigura::AbsCFigura(vector<CPunkt> Wierzcholki) : wierzcholki(vector<CPunkt>(4)) {
}
...
  1. Możesz tak zrobić że w klasie abstrakcyjnej (AbsCFigura) masz vector<CPunkt>. Ja bym ją całą uczynił jednak czysto abstrakcyjną.

  2. W double ObliczObwod(vector<CPunkt> wierzcholki), jak zrozumiałem z Twoich zamierzeń nie potrzebujesz przekazywać wierzchołków bo będziesz je miał dostępne przez this. Jeśli jednak źle Cię zrozumiałem, warto przekazać taki wektor przez const referencję np. tak:

double ObliczObwod(const vector<CPunkt>& wierzcholki);

Nie będziesz wtedy miał niepotrzebnego kopiowania wektora z CPunkt'ami.

  1. W CKwadrat::setWierzcholki() masz wczytywanie danych. Generalnie czy to jest odpowiedzialnością klasy by obsługiwać jeszcze in/out z konsoli? Raczej zrób w CKwadrat metodę która przyjmie wektor 4 wierzchołków (sugeruję także z const ref.) oraz dodaj konstruktor do CKwadrat przyjmujący taki wektor.

  2. W getterach dodaj const do metod. U Ciebie one nie powinny modyfikować atrybutów klas.

  3. Czy Twoje figury będą miały zawsze tylko 4 wierzchołki? Jeśli tak to nie ma sprawy. Jeśli jednak nie to deklarowanie "na sztywno" 4 elementów będzie uciążliwe w dalszej implementacji.

Zarejestruj się i dołącz do największej społeczności programistów w Polsce.

Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.