Tablica obiektów :: 4programmers.net

0

Witam, nie mogę sobie poradzić z programem tak by działał poprawnie. W komenatrzach zostało napisane co należy umieścić, zrobiłem wiekszość lecz nie wiem jak to poprawić by działało poprawnie. Pracuje Microsoft Visual Studio 2012.

program1.cpp

 

// Program1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "incl.h"
#include <math.h>
#include <iostream>
using namespace std;

void fun(NODE_COORD *ptr)
{
	for(int i=0; i<10; i++)
		(ptr+i)->disp();
}

void crash_memory()
{
	cout<<"Crash memory"<<endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	const double math_pi = 3.141592;
	double delta=2*math_pi/10;

	NODE_COORD tb[3] = { NODE_COORD(0, 0), NODE_COORD(1, 0), NODE_COORD(0, 1) };
	for(size_t i=0; i<3; ++i)
	{
		tb[i].disp();		//wyświetlić każdy element tablicy na monitorze
	}

	NODE_COORD * ptr = NULL, * tmp_ptr = NULL;

//zaalokować dynamicznie tablicę typu NODE_COORD o 10 elementów. Wskaźnik za //pomocą operatora new
//ptr dostaje adres tablicy

	try
	{
		ptr=new NODE_COORD[10];
	}
	catch(bad_alloc)
	{}

	tmp_ptr=ptr;
	for(size_t i=0; i<10; ++i)
	{
		//policzyć współrzędne x, y, leżące na okręgu o promieni r0
		//posługując wskaźnikiem tmp_ptr przypisać współrzędne x, y każdemu 
		//elementowi tablicy. Każdy element tablicy przedstawia punkt, leżący na 
		//okręgu o promieni r0

		double x=5 * cos(delta * i);
		double y=5 *sin(delta * i);

		tmp_ptr[i].set(x,y);
	}

	fun(ptr);	//stworzyć funkcje fun, która wydrukuje na monitorze współrzędne dla
			//wszystkich punktów, leżących na okręgu

	if(ptr)
		delete [] ptr;	//zwolnić pamięć dla tablicy obiektów 

	//zaalokować pamięć za pomocą funkcji malloc dla 10 elementów tablicy
	ptr = (NODE_COORD *)malloc(10*sizeof(NODE_COORD));
	if(!ptr)
		crash_memory(); //funkcja obsługi błędu w przypadku niepowodzenia

	tmp_ptr=ptr;

	for(size_t it = 0; it<10; ++it)
	{
		double x=5*cos(delta*it);
		double y=5*sin(delta*it);

		tmp_ptr[it].set(x,y);
		//policzyć współrzędne x, y, leżące na okręgu o promieni r0
		//posługując wskaźnikiem tmp_ptr przypisać współrzędne x, y każdemu 
		//elementowi tablicy. Każdy element tablicy przedstawia punkt, leżący na 
		//okręgu o promieni r0
	}

	fun(ptr);

	//co tu trzeba zrobić?
	for (int i=0; i<10; i++)
		ptr[i].clear();

	free(ptr);
	
	system("pause");
	return 0;
}

incl.h

 ////////////////////////////////////////////////////////////
///////////////////////incl.h


#ifndef CLASS_NODE_COORD
#define CLASS_NODE_COORD

class NODE_COORD
{
	double *pcoord;  //pcoord[0] - x, pcoord[1] - y
public:
	NODE_COORD() : pcoord(NULL) {}  	//konstruktor domyślny
	NODE_COORD(double x, double y); 	//konstruktor sparametryzowany
	~NODE_COORD();			//destruktor
	void set(double x, double y);	//ustala współrzedne x, y po inicjowaniu
	//void init(double x, double y);
	void disp();				//wyświetla na monitorze x, y

	
private:
	void crash();				//obsługuje błąd alokowania pamięci
};


#endif

incl.cpp

 
#include "stdafx.h"
#include "incl.h"
#include <iostream>
using namespace std;

NODE_COORD::NODE_COORD(double x, double y)
{
	try
	{
		pcoord=new double [2];
		pcoord[0]=x;
		pcoord[1]=y;
	}

	catch(bad_alloc)
	{
		crash();
	}
}

NODE_COORD::~NODE_COORD()
{
	if(pcoord)
	{
		delete [] pcoord;
		pcoord=NULL;
	}
}

void NODE_COORD::set(double x, double y)
{
	pcoord[0]=x;
	pcoord[1]=y;
}

void NODE_COORD::disp()
{
	cout<<"x= "<<pcoord[0]<<" y= "<<pcoord[1]<<endl;
}


void NODE_COORD::crash()
{
	cout<<"Blad alokacji"<<endl;
	system("pause");
	exit(1);
}

0

To co zrobiles moim zdaniem powinno byc karalne.

#include <iostream>
#include <cstdlib>
using namespace std;

class TEST {
	public:
		TEST() { cout << "Constructor;\n"; }
		~TEST() { cout << "Destructor;\n"; }
};

int main() {
	cout << "NEW / DELETE\n";
	TEST* ptr = new TEST;
	delete ptr;
	cout << "MALLOC / FREE\n";
	TEST* ptr2 = (TEST*)malloc(sizeof(TEST));
	free(ptr2);

	return 0;
}

Przanalizuj to sobie.

0

To jak w takim razie to poprawić by zadzaiałało?

0

try
        {
                ptr=new NODE_COORD[10];
        }
        catch(bad_alloc){}

Tworzysz 10 obiektow na stercie, kazdy z tych obiektow zawiera wskaznik do liczby double, wskaznik ten ma wartosc NULL.

tmp_ptr=ptr;

przypisujesz adres ptr do tmp_ptr (linijka bez sensu).

tmp_ptr[i].set(x,y);

wywolujesz funkcje set, dla wczesniej obliczonego x, y.

W FUNKCJI SET:

void NODE_COORD::set(double x, double y)
{
        pcoord[0]=x;
        pcoord[1]=y;
}

Zaraz, zaraz przeciez wskaznik pcoord ma wartosc NULL, czyzby to nie byl crash ?

0

Akurat nadal tego nie rozumiem. Jakbyś mógł mi napisać jak powinno być poprawnie, by program działał.

Zamieszczam oryginalna treść zadania.

 

class NODE_COORD
{
	double *pcoord;  //pcoord[0] - x, pcoord[1] - y
public:
	NODE_COORD() : pcoord(NULL) {cout << "konstruktor domysl: NODE_COORD\n";}
	NODE_COORD(double x, double y);	//konstruktor sparametryzowany
	~NODE_COORD();			//destruktor
	void set(double x, double y);	//ustala współrzędne x, y po inicjowaniu
	void disp();				//wyświetla na monitorze x, y
	

private:
	void crash();				//obsługuje błąd alokowania pamięci
};

Funkcja main wykonuje testowanie obiektów klasy:
int _tmain(int argc, _TCHAR* argv[])
{
	const double math_pi = 3.141592;
	NODE_COORD tb[3] = { NODE_COORD(0, 0), NODE_COORD(1, 0), NODE_COORD(0, 1) };
	for(size_t i=0; i<3; ++i)
	{
		//wyświetlić każdy element tablicy na monitorze
	}

	NODE_COORD * ptr = NULL, * tmp_ptr = NULL;
//zaalokować dynamicznie tablicę typu NODE_COORD o 10 elementów. Wskaźnik za //pomocą operatora new
//ptr dostaje adres tablicy

	tmp_ptr=ptr;
	for(size_t i=0; i<10; ++i)
	{
		//policzyć współrzędne x, y, leżące na okręgu o promieni r0
		//posługując wskaźnikiem tmp_ptr przypisać współrzędne x, y każdemu 
		//elementowi tablicy. Każdy element tablicy przedstawia punkt, leżący na 
		//okręgu o promieni r0
	}

	fun(ptr);	//stworzyć funkcje fun, która wydrukuje na monitorze współrzędne dla
			//wszystkich punktów, leżących na okręgu

	//zwolnić pamięć dla tablicy obiektów 

	//zaalokować pamięć za pomocą funkcji malloc dla 10 elementów tablicy
	ptr = (NODE_COORD *)malloc(10*sizeof(NODE_COORD));
	if(!ptr)
		crash_memory(); //funkcja obsługi błędu w przypadku niepowodzenia
	for(size_t it = 0; it<10; ++it)
	{
		//policzyć współrzędne x, y, leżące na okręgu o promieni r0
		//posługując wskaźnikiem tmp_ptr przypisać współrzędne x, y każdemu 
		//elementowi tablicy. Każdy element tablicy przedstawia punkt, leżący na 
		//okręgu o promieni r0
	}

	fun(ptr);

	//co tu trzeba zrobić?
	
	system("pause");
	return 0;
}

1

Jeżeli to:

        ptr = (NODE_COORD *)malloc(10*sizeof(NODE_COORD));
        if(!ptr)
                crash_memory(); //funkcja obsługi błędu w przypadku niepowodzenia

jest w oryginalnym zadaniu razem z tym:

class NODE_COORD
{
        double *pcoord;  //pcoord[0] - x, pcoord[1] - y
public:
        NODE_COORD() : pcoord(NULL) {cout << "konstruktor domysl: NODE_COORD\n";}
        NODE_COORD(double x, double y);        //konstruktor sparametryzowany
        ~NODE_COORD();                        //destruktor

To wykładowca który dal to zadanie powinien otrzymać dożywotni zakaz wykonywania zawodu
No chyba że wytłumaczył że dolna część to przykład tego jak nigdy nie należy robić.

0

używanie malloc w C++ nie należy do dobrego stylu programowania. Tracimy przez to możliwość wywołania konstruktora obiektu klasy.

0

Załącze swój działający kod, może komuś sie przyda :P

main>>

// zaj4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "incl.h"
#include <math.h>
#include<iostream>
#include<string>
#define delta 30

using namespace std;
NODE_COORD::NODE_COORD()
{
	pcoord = NULL;
	cout << "wywolanie konstruktora domyslnego" << endl;
}
void NODE_COORD::set(double x, double y) {
	if (!pcoord) {

		pcoord = new double[2];
	}

	pcoord[0] = x;
	pcoord[1] = y;

}


void NODE_COORD::crash()
{
	cout << "memory allocation error\n";
	system("pause");
	exit(1);
}

NODE_COORD::~NODE_COORD()
{
	cout << "destruktor" << endl;
	if (pcoord)
	{
		delete[] pcoord;
		pcoord = NULL;
	}
}

void NODE_COORD::disp() {
	cout << pcoord[0] << ",";
	cout << pcoord[1] << endl;

}

NODE_COORD::NODE_COORD(double x, double y) {
	cout << "wywoluje konstruktor sparametryzowany" << endl;
	
	try {
		
		pcoord = new double[2];
	
		pcoord[0] = x;
		pcoord[1] = y;

	}
	catch (bad_alloc) {
		crash();
	}
	
}


void fun(NODE_COORD *ptr)
{
	for (int i = 0; i<10; i++)
	ptr[i].disp();
}
void crash_memory()
{
	cout << "Crash memory" << endl;\
		exit(1);
}

int _tmain(int argc, _TCHAR* argv[])
{
	const double math_pi = 3.141592;
	NODE_COORD tb[3] = { NODE_COORD(0, 0), NODE_COORD(1, 0), NODE_COORD(0, 1) };
	for (size_t i = 0; i < 3; ++i)
	{
		tb[i].disp();
		//elementy tablicy to obiekty więc przypisalem pierwszy drogi itd element tablicy jako obiekt do wywolania metody display
		//wyświetlić każdy element tablicy na monitorze
	}

	NODE_COORD * ptr = NULL, *tmp_ptr = NULL;
	try {
		ptr = new NODE_COORD[10];

		//zaalokować dynamicznie tablicę typu NODE_COORD(tablice obiektow) o 10 elementów. Wskaźnik za //pomocą operatora new
		//ptr dostaje adres tablicy
	}
	catch (bad_alloc) {
		cout << "memory allocation error\n";
		system("pause");
		exit(1);
	}
	tmp_ptr = ptr;
	for (size_t i = 0; i < 10; ++i)
	{
		double x = 5 * cos(delta * i);//przyjmujemy ze okrąg ma srodek 
		//na początku układu wspolzednych i ma promien =5
		double y = 5 * sin(delta * i);

		tmp_ptr[i].set(x, y);



		//policzyć współrzędne x, y, leżące na okręgu o promieni r0
		//posługując wskaźnikiem tmp_ptr przypisać współrzędne x, y każdemu 
		//elementowi tablicy. Każdy element tablicy przedstawia punkt, leżący na 
		//okręgu o promieni r0
	}

	fun(ptr);	//stworzyć funkcje fun, która wydrukuje na monitorze współrzędne dla
				//wszystkich punktów, leżących na okręgu
	if (ptr) {
		delete[] ptr;
	}				//zwolnić pamięć dla tablicy obiektów 

				//zaalokować pamięć za pomocą funkcji malloc dla 10 elementów tablicy // malok odbiera nam mozliwosc wywołania konstruktora klasy >.<
	ptr = (NODE_COORD *)malloc(10 * sizeof(NODE_COORD));
	if (!ptr)
		crash_memory(); //funkcja obsługi błędu w przypadku niepowodzenia 
						//stosowanie maloka jest złym stylem programowania i odbiera mozliwosc wywolania konstruktora klasy


	tmp_ptr = ptr;
	for (size_t it = 0; it < 10; ++it)
	{

		double x = 5 * cos(delta * it);
		double y = 5 * sin(delta * it);

		
		new (tmp_ptr)NODE_COORD(x, y);
		tmp_ptr++;


	}
	fun(ptr);
	
	if (ptr) {
	free(ptr);
	ptr = NULL;
}
	//co tu trzeba zrobić? 

	system("pause");
	return 0;
}

header z deklaracją klasy.

#pragma once
#include <stdio.h>


using namespace std;
class NODE_COORD
{
	double *pcoord;  //pcoord[0] - x, pcoord[1] - y
public:
	NODE_COORD(); 	//konstruktor domyślny
	NODE_COORD(double x, double y); 	//konstruktor sparametryzowany
	~NODE_COORD();			//destruktor
	void set(double x, double y);//pozwala na zmianę współrzędnych x, y
	void disp();				//wyświetla na monitorze x, y

private:
	void crash();				//obsługuje błąd alokowania pamięci
};

Tablica obiektów

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

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami