Tablica obiektów

 

// 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


#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

 
#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);
}

#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;
}

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

tmp_ptr=ptr;

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

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

 

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;
}

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

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