Szablon i tworzenie obiektu podczas kompilacji

Question

Witam wszystkich

chcę ustalić jaki typ będzie używany podczas kompilacji, myślałem że uda mi się w taki sposób, ale oczywiście to nie działa. Mógłby mi ktoś podpowiedzieć jak mam rozwiązać taki problem?

#include "LWymierna.h"
#include "Stos.cpp"
int main()
{
	char option;
	int opt;
	Stos *s;
	cout << "STACK CALCULATOR\n------------------------------------------\n";
	do
	{
		cout << "Jakiego typu liczby beda uzywane ? \n1 - int\n2 - double\n3 - liczby wymierne\n";
		cin >> opt;
		if (opt == 1)
			s = new Stos<int>;
		else if (opt == 2)
			s = new Stos<double>;
		else if (opt == 3)
			s = new Stos<LWymierna>;

	} while (opt != 1 && opt != 2 && opt != 3);
	...
        s -> ~Stos();
	system("PAUSE");
	return 0;
}

 

Pozdrawiam

 

Comments

 #include "Stos.cpp"
...

 s -> ~Stos(); 

WTF?! O new słyszał, a o delete nie? Plików źródłowych się nie includuje, tylko dodaje do projektu opcją twojego IDE.

 

chcę ustalić jaki typ będzie używany podczas kompilacji,

Podczas kompilacji, czy w czasie działania programu? Z kodu wynika, że chodzi o to drugie.

 

---

#include "Stos.cpp"

s -> ~Stos();

Wiesz co robisz w ogóle? Doczytaj różnice między headerami i plikami źródłowymi. Doczytaj jak sie dealokuje pamięć.

ale oczywiście to nie działa

 A, no tak. Wszystko jasne.

Answer 1

Najprościej jak się da:

template <typename T> 
void stack_calculator()
{
	// tutaj reszta programu dla typu T
}


int main()
{
	...
	
	while(cin)
	{
		cout << "Jakiego typu liczby beda uzywane ? \n1 - int\n2 - double\n3 - liczby wymierne\n";
		cin >> opt;

		switch(opt)
		{
		case 1:	stack_calculator<int>(); break;
		case 2:	stack_calculator<double>(); break;
		case 3:	stack_calculator<LWymierna>(); break;
		default: continue;
		}

		break;
	} 


	...
}

 

Comments

Podzieliłem na pliki nagłówkowe i źródłowe, poprawiłem dealokację pamięci (mam nadzieję) i zrobiłem Twoim sposobem i działa. Dzięki za pomoc.

 

Możesz napisać czy nie ma już żadnych, aż tak rażących błędów?

#ifndef stackc_h
#define stackc_h
#include "LWymierna.h"
#include <string>

template <typename T>
class StackCalculator
{
private:
	struct element
	{
		T type;
		element* next;
	};

	typedef element ELEMENT;
	ELEMENT *first;

public:
	StackCalculator();
	~StackCalculator();
	void push(T t);
	T pop();
	void display();
	void push(std::string s);
	void dzialanie();
};
#endif

 

#include "StackCalculator.h"
using namespace std;

template <typename T>
StackCalculator<T>::StackCalculator()
{
	first = NULL;
}

template <typename T>
StackCalculator<T>::~StackCalculator()
{
	while (first != NULL)
	{
		ELEMENT *e;
		e = first;
		first = first->next;
		delete e;
	}
}

template<typename T>
void StackCalculator<T>::push(T t)
{
	ELEMENT *e = new element;
	e->type = t;
	e->next = first;
	first = e;
}

template<typename T>
T StackCalculator<T>::pop()
{
	if (first != NULL)
	{
		ELEMENT *e = first;
		first = first->next;
		T t = e->type;
		delete e;
		return t;
	}
	throw runtime_error("Stos pusty!");
}

template<typename T>
void StackCalculator<T>::display()
{
	ELEMENT *e = first;
	while (e != NULL)
	{
		cout << e->type << endl;
		e = e->next;
	}
}

template<typename T>
void StackCalculator<T>::push(std::string s)
{
	if (first != NULL && first->next != NULL)
	{
		if (s == "+")
		{
			push(pop() + pop());
		}
		else if (s == "-")
		{
			push(pop() - pop());
		}
		else if (s == "*")
		{
			push(pop() * pop());
		}
		else if (s == "/")
		{
			push(pop() / pop());
		}
		else
		{
			throw runtime_error("Zly znak!\n");
		}
	}
	else
		throw runtime_error("Zbyt malo elementow na stosie\n");
}

template<typename T>
void StackCalculator<T>::dzialanie()
{
	char temp = 'a';
	do
	{
		cout << "Co chcesz zrobic?\nD - dodaj element\nZ - dodaj dzialanie\nW - wyswietl elementy\nU - usun ostatnia liczbe\nQ - wyjdz\n";
		cin >> temp;
		switch (temp)
		{
			case 'D':
			{
				T t;

				cout << "Podaj liczbe:\n";
				cin >> t;
				push(t);
				break;
			}
			case 'Z': 
			{
				string s;
				cout << "Wpisz dzialanie:\n";
				cin >> s;
				push(s);
				break;
			}
			case 'W': display(); break;
			case 'U': pop(); break;
		}
	} while (temp != 'Q');
}

int main()
{
	int opt;

	
	cout << "Jakiego typu liczby beda uzywane ? \n1 - int\n2 - double\n3 - liczby wymierne\n";
	cin >> opt;


	switch (opt)
	{
		case 1:
        {
            StackCalculator<int> *s = new StackCalculator<int>();
            s->dzialanie();
            s->~StackCalculator();
            delete s;
        }
        case 2:
        {
            StackCalculator<double> *s = new StackCalculator<double>();
            s->dzialanie();
            s->~StackCalculator();
            delete s;
        }
        case 3:
        {
            StackCalculator<LWymierna> *s = new StackCalculator<LWymierna>();
            s->dzialanie();
            s->~StackCalculator();
            delete s;
        }
	}

	system("PAUSE");
	return 0;
}

 

---

StackCalculator<int> *s = new StackCalculator<int>();

...

s->~StackCalculator();

delete s;

 

Co Ty masz z tym wywoływaniem destruktora? delete jest od tego. Zresztą tu nie ma potrzeby tworzenia obiektów s na stercie. Wystarczy tak:

case 1:
{
        StackCalculator<int> s;
        s.dzialanie();
        break;
}
case 2:
{
        StackCalculator<double> s;
        s.dzialanie();
        break;
}
case 3:
{
        StackCalculator<LWymierna> s;
        s.dzialanie();
        break;
}

O breakach w switchu zapomniałeś...

struct element { ...};

typedef element ELEMENT;

 

Po co ten typedef?

 

Na razie tyle, być może są tam jeszcze jakieś błędy.