Statický zásobník pomocí třídy – C / C++ – Fórum – Programujte.com

Ahoj , mám za úkol implementovat třídu zásobník a třídu televize, v mainu mám naplnit zásobník jednotlivými instancemi třídy televize. Nějaký kod jsem zplodil, ale nevím jestli je to dobře. Byl bych rád za každou radu.

Hlavičkové soubory:

http://pastebin.com/jZ0NBr9s

http://pastebin.com/Kr1hGQmp

#include<iostream>
#include "televize.h"
#include "stack.h"


using namespace std;

int main(void)
{
	Televize t1;
	Televize t2;
	Televize t3;
	Stack s1;
	s1.Push(s1,t1);
	s1.Push(s1,t2);
	s1.Pop(s1);
	s1.Push(s1,t2);

	return 0;
}

má to dáky skrytý význam, že zásobníku ako prvý argument pri všetkých metódach predávaš inštanciu triedy?

ak to nemmá hlbší skytý význam tak by som to skúsil takto:

void Stack::Push(Televize t)
{
        if(IsFull(*this) != true)
        {
                Data[pointer++] = t;
        }
        else
                cout << "\n\nZasobnik je plny!\n\n";
}
 

prípadne aj isFull(stack &s) má argument ktorý vôbec nevyužíva tak ho odstrániť :)

Ten tvoj zasobnik by mohol vyzerat takto:

#include <stdexcept>
template <class T, size_t N>
class Stack
{
        private:
                T data[N];
                size_t pointer;
 
        public:
                Stack():pointer(0){}
                bool IsEmpty(){return (pointer == 0);}
                bool IsFull(){return (pointer == N);};
                void Push(const T& t){
			if(IsFull())throw std::logic_error("Zasobnik je plny!");
					
			data[pointer++] = t;	
		}
                T Pop(){
			if(IsEmpty())throw std::logic_error("Zasobnik je prazdny!");
					
			return data[--pointer];
		}
 
};

int main(void)
{
	Televize t1;
	Televize t2;
	Televize t3;
	Stack<Televize, 3> s1;
	s1.Push(t1);
	s1.Push(t2);
	s1.Pop();
	s1.Push(t2);

	return 0;
}

#3 vitamin
Díky moc za reakce, ohledně použití template a  knihovny stdexcept, jsem se ještě nesetkal, ale snad jsem to pochopil.

#2 nergal
Žádný význam to nemá, ale myslel jsem si, že to bude lepší, když to takhle udělám. Dám na tvoji radu a odstraním to. Díky moc.

#4 Michal
stdexcept je tam len kvoly vynimke std::logic_error.

Ak sa ti nechce implementovat vlastny stack, tak mozs pouzit adapter std::stack.

#include <stack>
#include <iostream>

int main(){
    std::stack<int> stack;	//alebo std::stack<int, std::vector<int>> stack;

    stack.push(1);
    stack.push(2);
    stack.pop();
    stack.push(3);

    std::cout << stack.top();
}

Ja som si uz raz implementoval stack ktory pouziva polia, kludne ho mozes pouzit ak chces:

#include <iostream>
#include <algorithm>
#include <initializer_list>
#include <type_traits>


template <class T, size_t N>
class stack final{
	template <typename, size_t>
	friend class stack;
	
	public:
		typedef T value_type;
		typedef T& reference;
		typedef const value_type& const_reference;
		typedef T* pointer;
		typedef const T* const_pointer;
		
	private:
		char data[sizeof(value_type)*N];
		size_t pos;
		
		inline pointer t_data(size_t i){return reinterpret_cast<pointer>(data) + i;}
		inline const_pointer t_data(size_t i)const{return reinterpret_cast<const_pointer>(data) + i;}
		
	public:
		stack():pos(0){}
		
		stack(size_t n){
			pos = std::min(N, n);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type();
		}
		
		stack(size_t n, const_reference t){
			pos = std::min(N, n);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(t);
		}
		
		template <class U, size_t M>
		stack(const stack<U, M>& s){
			pos = std::min(N, s.pos);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(*s.t_data(i));
		}
		
		template <class U, size_t M>
		stack(stack<U, M>&& s){
			pos = std::min(N, s.pos);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(std::move(*s.t_data(i)));
		}
		
		template <class I>
		stack(I beg, I end){
			for(pos = 0; (beg != end) && (pos < N); ++beg, ++pos)
				new(t_data(pos)) value_type(*beg);
		}
		
		stack(std::initializer_list<T>&& inic_list){
			auto beg = std::begin(inic_list);
			auto end = std::end(inic_list);
			for(pos = 0; (beg != end) && (pos < N); ++beg, ++pos)
				new(t_data(pos)) value_type(std::move(*beg));
		}

		~stack(){
			if(!std::is_trivial<value_type>::value)
				for(size_t i = pos; i > 0; --i)
					t_data(i-1)->~value_type();
		}
		
		void clear(){
			if(!std::is_trivial<value_type>::value)
				for(; pos > 0; --pos)
					t_data(pos-1)->~value_type();
			pos = 0;
		}
			
		size_t size()const{return pos;}
		constexpr size_t max_size()const{return N;}
		bool empty()const{return (pos == 0);}
		bool full()const{return (pos == N);}
		
		template <class U>
		void push(const U& u){
			new(t_data(pos)) value_type(u);
			++pos;
		}
		
		template <class U>
		void push(U&& u){
			new(t_data(pos)) value_type(std::move(u));
			++pos;
		}
		
		template <class... Args>
		void emplace(Args... args){
			new(t_data(pos)) value_type(args...);
			++pos;
		}
		
		void pop(){
			--pos;
			t_data(pos)->~value_type();
		}
		
		const_reference top(){
			return *t_data(pos-1);
		}	
};

#6 vitamin
Aha, díky moc za objasnění.