Не завершается функция!

[Theseus]

Вот код:

//testing_2.cpp
#include "stack_3.h"
#include "my_string.h"
#include "my_time.h"
void show(stack_3<my_string> in);
int main()
{
	stack_3<my_string> lol;
	lol.push("I love you Konata!");
	lol.push("English is very good language");
	lol.push("Good job C++");
	show(lol);
	std::cout<<std::endl<<"Out of funtion!";
	
	time_delay(1.8);
	return false;
}
void show(stack_3<my_string> in)
{
	my_string l;
	while(!in.empty())
	{
		in.pop(l);
		std::cout<<l<<endl;
	}
	std::cout<<"lalala!";
}

последнее что выводится это строка "lalala!" и все программа зависает или чёрт его знает что с ней случается. Она должна подождать 1.8 секунд и завершится, если закомментировать show(lol); то так и происходит, а так она просто стоит и ждет непонятно чего и вырубается только закрыванием окошка. В чём здесь может быть проблема?

[Stilet]

time_delay что делает? Из чего состоит?
Что показывает трассировка кода?

[Theseus]

Сообщение от Stilet

time_delay что делает? Из чего состоит?
Что показывает трассировка кода?

программа не доходит до std::cout<<std::endl<<"Out of funtion!"; так что time_delay() тут не причём, time_delay() останавливает программу на n сек. Вот её определение:

void time_delay(const float & secs)
{
	clock_t delay=secs*CLOCKS_PER_SEC;
	clock_t start=clock();
	while(clock()-start<delay);
}

Но проблема не в ней т.к. до неё ещё есть оператор std::cout<<std::endl<<"Out of funtion!"; который не выводиться, следовательно, программа не выходит из функции show(), хотя цикл в этой функции завершается поскольку выполняется оператор std::cout<<"lalala!"; и выводиться строка lalala! Но вот почему функция не завершается - непонятно!

[Stilet]

Поставь для уверености return в конец функции show().
Ничего такого не скажу - хедеры свои ты не раскрыл.
Устраивай пошаговку, и смотри как while(!in.empty()) себя ведет.

[Theseus]

Сообщение от Stilet

Поставь для уверености return в конец функции show().
Ничего такого не скажу - хедеры свои ты не раскрыл.
Устраивай пошаговку, и смотри как while(!in.empty()) себя ведет.

Вот устроил, выдаёт такое:


Вот новый код:

//testing_2.cpp
#include <cstdlib>
#include "stack_3.h"
#include "my_string.h"
#include "my_time.h"
int show(stack_3<my_string> in);
int main()
{
	stack_3<my_string> lol;
	lol.push("I love you Konata!");
	lol.push("English is very good language");
	lol.push("Good job C++");
	show(lol);
	std::cout<<std::endl<<"Out of funtion!";
	
	
	time_delay(1.8);
	return false;
}
int show(stack_3<my_string> in)
{
	my_string l;
	while(!in.empty())
	{
		in.pop(l);
		std::cout<<l<<std::endl;
		std::cout<<"in.empty() is: "<<(in.empty()?"true":"false")<<std::endl;
		system("pause");
	}
	std::cout<<"lalala!";
	return false;
}

Вот хедеры, но не думаю что они чем-то помогут.

stack_1.h

//stack_1.h
#ifndef _stack_1_
#define _stack_1_
#include <iostream>
template<typename type1>
struct node
{
		type1 item;
		node * next;
};
template<typename type1>
class stack_1
{
	enum {MAX=10};
	protected:
		node<type1> * front;
		int quantity;
		int max_quantity;
	public:
		void clear();
		stack_1(int max=MAX);
		~stack_1();
		bool empty();
		bool full();
		bool add(const type1 & to_add);
		bool del();
		bool get(type1 & get);
};
template<typename type1>
void stack_1<type1>::clear()
{
	node<type1> * temp;
	while(front)
	{
		temp=front;
		front=temp->next;
		delete temp;
	}
	quantity=0;
}
template<typename type1>
stack_1<type1>::stack_1(int max)
{
	front=0;
	quantity=0;
	max_quantity=max;
}
template<typename type1>
stack_1<type1>::~stack_1()
{
	clear();
}
template<typename type1>
bool stack_1<type1>::empty()
{
	return quantity==0;
}
template<typename type1>
bool stack_1<type1>::full()
{
	if(quantity==max_quantity) return 1;
	return 0;
}
template<typename type1>
bool stack_1<type1>::add(const type1 & to_add)
{
	if(quantity==max_quantity) return 1;
	node<type1> * temp=new node<type1>;
	temp->item=to_add;
	temp->next=front;
	front=temp;
	quantity++;
	return 0;
}
template<typename type1>
bool stack_1<type1>::del()
{
	if(front==0) return 1;
	node<type1> * temp=front;
	front=front->next;
	delete temp;
	quantity--;
	return 0;
}
template<typename type1>
bool stack_1<type1>::get(type1 & get)
{
	if(front==0) return 1;
	get=front->item;
	return 0;
}
#endif

stack_2.h

//stack_2.h
#ifndef _stack_2_
#define _stack_2_
#include "stack_1.h"
template <typename type2>
class stack_2 : public stack_1<type2>
{
	enum {MAX=10};
	public:
		stack_2(int max=MAX);
		bool push(const type2 & in);
		bool pop(type2 & out);
};
template <typename type2>
stack_2<type2>::stack_2(int max) : stack_1<type2>(max)
{
	//constructor
}
template <typename type2>
bool stack_2<type2>::push(const type2 & in)
{
	return stack_1<type2>::add(in);
}
template <typename type2>
bool stack_2<type2>::pop(type2 & out)
{
	return stack_1<type2>::get(out)||stack_1<type2>::del();
}
#endif

stack_3.h

//stack_3.h
#ifndef _stack_3_
#define _stack_3_
#include "stack_2.h"
template <typename type3>
class stack_3 : public stack_2<type3>
{
	enum {MAX=10};
	public:
		stack_3(int max=10);
		stack_3(const stack_3<type3> & to_copy);
		stack_3<type3> & operator=(const stack_3<type3> & to_assignment);
};
template <typename type3>
stack_3<type3>::stack_3(int max) : stack_2<type3>(max)
{
	//constructor
}

template <typename type3>
stack_3<type3>::stack_3(const stack_3 & to_copy)
{
	stack_2<type3>::front=0; stack_2<type3>::quantity=to_copy.quantity;
	stack_2<type3>::max_quantity=to_copy.max_quantity;
	node<type3> * temp, * temp_out=to_copy.front;
	if(temp_out!=0)
	{
		temp=new node<type3>;
		stack_2<type3>::front=temp;
		temp->item=temp_out->item;
		temp_out=temp_out->next;
	}
	while(temp_out!=0)
	{
		temp->next=new node<type3>;
		temp=temp->next;
		temp->item=temp_out->item;
		temp_out=temp_out->next;
	}
}
template <typename type3>
stack_3<type3> & stack_3<type3>::operator=(const stack_3<type3> & to_assignment)
{
	stack_2<type3>::front=0; stack_2<type3>::quantity=to_assignment.quantity;
	stack_2<type3>::max_quantity=to_assignment.max_quantity;
	node<type3> * temp, * temp_out=to_assignment.front;
	if(temp_out!=0)
	{
		temp=new node<type3>;
		stack_2<type3>::front=temp;
		temp->item=temp_out->item;
		temp_out=temp_out->next;
	}
	while(temp_out!=0)
	{
		temp->next=new node<type3>;
		temp=temp->next;
		temp->item=temp_out->item;
		temp_out=temp_out->next;
	}
}
#endif

[Theseus]

my_string.h

//my_string.h
#ifndef _my_string_
#define _my_string_
#include <iostream>
using namespace std;
int length(const char * in);
void copy(const char * in, char * out);
void ncopy(const char * in, char * out, int n);
class my_string
{
	private:
		char * str;
	public:
		my_string();
		my_string(const char * in);
		my_string(my_string & in);
		~my_string();
		int len();
		friend int length(const char * in);
		friend void copy(const char * in, char * out);
		friend void ncopy(const char * in, char * out, int n);
		my_string & operator=(const my_string & in);
		my_string & operator=(const char * in);
		friend istream & operator>>(istream & in, my_string & s);
		friend ostream & operator<<(ostream & out, const my_string & s);
		my_string operator+(my_string & in);
		char sym(const int n);
		int sym(const char n);
		void up();
		void low();
		void con();
		friend bool comparison(const char * left, const char * right);
		bool operator==(const char * right);
		friend bool operator==(const char * left, const my_string & right);
		bool operator==(const my_string * right);
		bool operator==(const my_string & right);
		friend void ncopy_without(const char * in, char * out, int n);
};
my_string::my_string()
{
	str=0;
}
my_string::my_string(const char * in)
{
	str=new char[length(in)+1];
	copy(in, str);
}
my_string::my_string(my_string & in)
{
	str=new char [length(in.str)];
	copy(in.str, str);
}
my_string::~my_string()
{
	delete [] str;
}
int my_string::len()
{
	return length(str);
}
int length(const char * in)
{
	int i=0;
	while(*(in+i++)!='\0');
	return i-1;
}
void copy(const char * in, char * out)
{
	ncopy(in, out, length(in));
}
void ncopy(const char * in, char * out, int n)
{
	*(out+n)='\0';
	while(n--) *(out+n)=*(in+n);
}
my_string & my_string::operator=(const my_string & in)
{
	delete [] str;
	str=new char [length(in.str)+1];
	copy(in.str, str);
	return *this;
}
my_string & my_string::operator=(const char * in)
{
	delete [] str;
	str=new char [length(in)+1];
	copy(in, str);
	return *this;
}
istream & operator>>(istream & in, my_string & s)
{
	char * temp=new char[100];
	in.get(temp, 99); in.sync();
	int len=length(temp);
	s.str=new char[len+1];
	ncopy(temp, s.str, len);
	return in;
}
ostream & operator<<(ostream & out, const my_string & s)
{
	out<<s.str;
	return out;
}
my_string my_string::operator+(my_string & in)
{
	my_string temp;
	int len_this=length(str), len_out=length(in.str);
	temp.str=new char[len_this+len_out+1];
	ncopy(str, temp.str, len_this);
	ncopy(in.str, temp.str+len_this, len_out);
	return temp;
}
char my_string::sym(const int n)
{
	if(n>length(str)) return '\0';
	return *(str+n-1);
}
int my_string::sym(const char n)
{
	int i=0, k=0;
	while(*(str+i)!='\0') if(*(str+i++)==n) k++;
	return k;
}
void my_string::up()
{
	int i=0, k;
	while(*(str+i)!='\0')
	{
		k=*(str+i);
		if(k>=97&&k<=122) *(str+i)-=32;
		i++;
	}
}
void my_string::low()
{
	int i=0, k;
	while(*(str+i)!='\0')
	{
		k=*(str+i);
		if(k>=65&&k<=90) *(str+i)+=32;
		i++;
	}
}
void my_string::con()
{
int i=0, k;
	while(*(str+i)!='\0')
	{
		k=*(str+i);
		if(k>=97&&k<=122) *(str+i)-=32;
		if(k>=65&&k<=90) *(str+i)+=32;
		i++;
	}
}
bool comparison(const char * left, const char * right)
{
	int i=0;
	while(*(left+i)!='\0'||*(right+i)!='\0') if(*(left+i)!=*(right+i++)) return 0;
	return 1;
}
bool my_string::operator==(const char * right)
{
	return comparison(str, right);
}
bool operator==(const char * left, const my_string & right)
{
	return comparison(left, right.str);
}
bool my_string::operator==(const my_string * right)
{
	return comparison(str, right->str);
}
bool my_string::operator==(const my_string & right)
{
	return comparison(str, right.str);
}
void ncopy_without(const char * in, char * out, int n)
{
	while(n--) *(out+n)=*(in+n);
}
#endif

[Theseus]

И вот на всякий случай my_time.h

//this is a class for representation a time in format hh:mm
#ifndef _my_time_
#define _my_time_
#include <iostream>
#include <ctime>
using namespace std;
class my_time
{
	private:
		int min;
		int hour;
	public:
		my_time();
		my_time(int in_min);
		my_time(int in_min, int in_hour);
		friend istream & operator>>(istream & in, my_time & read);
		friend ostream & operator<<(ostream & out, const my_time & write);
		my_time operator+(my_time & right);
		my_time operator-(my_time & right);
		my_time operator*(int right);
		friend my_time operator*(int left, my_time & right);
		//transformation to the "int" in minute
		operator int();
		int to_int();
};
my_time::my_time()
{
	min=0;
	hour=0;
}
my_time::my_time(int in_min)
{
	hour=in_min/60;
	min=in_min%60;
}
my_time::my_time(int in_hour, int in_min)
{
	hour=in_hour;
	min=in_min;
}
istream & operator>>(istream & in, my_time & read)
{
	cout<<"time (hh mm): ";
	in>>read.hour>>read.min;
	return in;
}
ostream & operator<<(ostream & out, const my_time & write)
{
	out<<"time is:  ";
	if(write.hour<10&&write.hour>-10) out<<"0";
	if(write.hour<0) out<<write.hour*(-1);
	else out<<write.hour;
	out<<":";
	if(write.min<10&&write.min>-10)out<<"0";
	if(write.min<0) out<<write.min*(-1);
	else out<<write.min;
	if(write.hour<0) out<<"\b\b\b\b\b\b-\n";
	else out<<"\n";
	return out;
}
my_time my_time::operator+(my_time & right)
{
	my_time result;
	result.hour=hour+right.hour+(min+right.min)/60;
	result.min=(min+right.min)%60;
	return result;
}
my_time my_time::operator-(my_time & right)
{
	my_time result;
	result.hour=((hour*60+min)-(right.hour*60+right.min))/60;
	result.min=((hour*60+min)-(right.hour*60+right.min))%60;
	return result;
}
my_time my_time::operator*(int m)
{
	my_time result;
	result.hour=hour*m+(min*m)/60;
	result.min=(min*m)%60;
	return result;
}
my_time operator*(int left, my_time & right)
{
	return right*left;
}
int my_time::to_int()
{
	return hour*60+min;
}
my_time::operator int()
{
	return hour*60+min;
}
void time_delay(const float & secs)
{
	clock_t delay=secs*CLOCKS_PER_SEC;
	clock_t start=clock();
	while(clock()-start<delay);
}
#endif

[Stilet]

У меня твой код падает на ошибку доступа к памяти тут:

void stack_1<type1>::clear()
{
node<type1> * temp;
while(front)
{
temp=front;
front=temp->next;
delete temp;
}
quantity=0;
}

Я не большой спец по Сям, так что ты сам поанализируй ошибку, протрассировав код.

[Theseus]

Сообщение от Stilet

У меня твой код падает на ошибку доступа к памяти тут:


Я не большой спец по Сям, так что ты сам поанализируй ошибку, протрассировав код.

Да я уже нашёл, спасибо, только хотел написать что ошибка оказывается была в том что конструктор копирования неправильно копировал цепочку nodo'в и в результате не добавлял нулевой адрес значению next последнего нода. Только вот теперь вопрос: почему у меня компилятор не ругался на этот код несмотря на то что он обращается к "левой" памяти? Ты каким компилятором это все компилировал?

[Stilet]

Ты каким компилятором это все компилировал?

Визуал Студия 2010.
И я весь твой код в один CPP файл кинул. Не делил на хедеры.