Hello! Why does visual studio closing my code?!

[NOvadia]

Hello!!

I wrote some code, and when I built it, everything is going good, there is no errors, but when I try to run it with Ctrl+F5, it runs.. when it finishes running, just closes without writing me "press and key to continue.."

If I put there a "Break point" or "system("pause")" it does work!

(The auto reviewer of Moodle writes me "Out of memory"...)

What can cause it?

Thanks!!

[Moschops]

Why would it NOT do that?

Think about what's happening here. You are running a program. It's not Visual Studio "running your code". A computer program is being made. An executable file is being created and placed on your hard-drive, and then it's being run, just like any other executable file. It's just like every other computer program on your PC.

What happens when a computer program finishes? What happens when Microsoft Word finishes, or Firefox finishes? They go away. They close. They stop running and disappear. That's what's meant to happen.

Visual Studio isn't "closing your code". Your computer program, that YOU wrote, is finishing, and when a computer program on your PC finishes, that's what happens.

[NOvadia]

OK.... so I wasn't clear..

So that why I wrote

I try to run it with Ctrl+F5, it runs.. when it finishes running, just closes without writing me "press and key to continue.."

Because all the other code was not just closed without pressing any key! Even when he had finished running...

[Chervil]

Are you saying that your program crashed with an "Out of memory" error?

If so, you'd need to show us your code in order to help identify any problems.

[NOvadia]

This code is part of exercise we should do in our place of study... and we need to upload it via moodle. Any way, there is an auto reviewer that debug our code, I think that its compiler is Code Blocks, but I'm not sure about it...

So... in visual studio the code just closed without any problem.
In Moodle ( Code Blocks ? ) can not evaluate my exercise - writing "Out of memory".

I wrote it in a brackets cause it might give some clue what went wrong ...
And about to show the code - I don't have any problem... but It's quite long... so I hoped someone has an idia that can lead me to the problem.
(Again, I assume because I have no errors in visual studio, that there is something fundamental...)

Thanks!!

[Chervil]

When you say "I have no errors in visual studio" I presume you mean there are no compiler errors. However, it seems you have a run-time error, which is something the compiler cannot identify, since it doesn't happen until the program is actually run.

Again - it's not possible to say what the problem might be without seeing the code.

[NOvadia]

This is a Linked list:
List.cpp

#include "List.h"
//------------------------------------------------
//  class Link implementation
//------------------------------------------------
List::Link::Link( int val, Link* nxt) : value(val), next(nxt)   {}

List::Link::Link(const Link& source) : value(source.value),next(source.next)  {}
 
//--------------------------------------------
//  class List implementation
//--------------------------------------------
List::List(): head(NULL)
{
	//cout << "CTOR\n";
}

// Copy constructor
List::List(const List &l) 
{
	//cout << "Copy CTOR\n";
	Link *src, *trg;
	if(l.head == NULL)
		head = NULL;
	else
	{  // copy the list
		head = new Link((l.head)->value, NULL);
		src = l.head;
		trg = head;
		while(src->next != NULL)
		{
			trg->next = new Link((src->next)->value, NULL);
			src = src->next;
			trg = trg->next;
		}
	}
}


void List::operator=(const List& l)
{
	if(&l != this)
	{
		this->clear();
		Link *src, *trg;
		if(l.head == NULL)
			head = NULL;
		else
		{  // copy the list
			head = new Link((l.head)->value, NULL);
			src = l.head;
			trg = head;
			while(src->next != NULL)
			{
				trg->next = new Link((src->next)->value, NULL);
				src = src->next;
				trg = trg->next;
			}
		}
	}
}

// Destructor
List::~List()
{
	//cout << "DTOR: ";
	//print();
	clear();
}

void List::clear()
{
	// empty all elements from the List
	Link* next;
	for (Link *p = head; p != NULL; p = next)
	{
		// delete the element pointed to by p
		next = p->next;
		p->next = NULL;
		delete p;
	}
	// mark that the List contains no elements
	head=NULL;
}

// test to see if the List is empty
// List is empty if the pointer to the head
// Link is null
bool List::isEmpty() const
{
	return head == NULL;
}
 
//Add a new value to the front of a Linked List
void List::add(int val)
{
	head = new Link(val, head);
	if(head == NULL) 
		throw "failed in memory allocation";
}

// return first value in List
int List::firstElement() const
{
	if (isEmpty())
		throw "the List is empty, no first Element";
	return head->value;
}

bool List::search(const  int &val) const
{
	// loop to test each element
	for (Link* p = head; p != NULL ; p = p->next)
		if (val == p->value)
			return true;
	// not found
	return false;
}

void List::print() const
{
	for (Link* p = head; p != NULL ; p = p->next)
		cout << p->value << ((p->next != NULL) ? " -> " : "\n"); 
}

void List::removeFirst()
{
	// make sure there is a first element
	if(isEmpty())
		throw "the List is empty, no Elements to remove";
	// save pointer to the removed node
	Link* p = head;
	// reassign the first node
	head = p->next;
	p->next = NULL;
	// recover memory used by the first element
	delete p;
} 
void List::reverse()//revesing the list, in case each time the bigger element is first.
{
	List temp;
	while (!isEmpty())
	{
		temp.add(firstElement());
		removeFirst();
	}
	*this=temp;
}

ostream& operator<<(ostream& out, List& l)
{
	List::Link*p = l.head;
	if (l.head != NULL)
	{
		do
		{
			out << p->value << " ";
			p = p->next;
		} while (p != NULL);
	}
	return out;
}

istream &operator>>(istream& in, List& l)
{
	int help = 0;
	in >> help;

	if (l.head == NULL)
	{
		l.add(help);
		in >> help;
	}
	do
		{
			l.add(help);
			in >> help;
	} while (l.head->value == help || l.head->value<help);
	l.reverse();//because the last element was the bigger, we need to reverse.
	return in;
}

void List::insert(int key)//inserting a new element, Keeps ascending
{
	List::Link *first = head;//i will use it as the first element in the new list during insertion 
	if (head != NULL)
	{
		List::Link *second = head->next; //will use it as second element during insertion
		if (head->value >= key)//extreme case if it will needed to be insert to the first place
		{
			add(key);
			return;
		}
		do//to the middle...
		{
			if (second->value>=key)
			{
				first->next = new Link(key, second);
				return;
			}
			first = second;
			second = first->next;
		} while (second != NULL);
		first->next = new Link(key, NULL);//if not first and not to the middle..
	}
}

void List::remove(int key)//remove element by value
{
	if (!search(key))
		throw "value not found";
	List::Link *first = head;
	if (head != NULL)
	{
		if (head->value == key)//extreme case if it the first element
		{
			removeFirst();
		}
		else
		{
			List::Link *second = first->next;//will use it as second element during insertion
			do
			{
				if (second->value == key)
				{
					first->next = second->next;
				}
				first = second;
				second = first->next;
			} while (second != NULL);
		}
	}
}

List merge(List lst1, List lst2)
{
	List temp; //the new sorting list
	List::Link *list1 = lst1.head; //list a
	List::Link *list2 = lst2.head; //list b

	while (list1 != NULL && list2 != NULL)
	{
		if (list1->value < list2->value) //cheking if the value of the first smaller then the second and coefficient on
		{
			temp.add(list1->value);
			list1 = list1->next;
		}
		else // else copy from list b and coefficient on
		{
			temp.add(list2->value);
			list2 = list2->next;
		}
	} 

 //one of the lists must be empy (less they are equal..)
	while (list1!=NULL)
	{
		temp.add(list1->value);
		list1 = list1->next;
	}
	while (list2!=NULL)
	{
		temp.add(list2->value);
		list2 = list2->next;
	}
	temp.reverse();//becuse the bigger element was the last..
	return temp;
}


List makeSet(List& lst) //remove duplicate elements.
{
	List temp; //new list
	List::Link *list = lst.head;
	int flag = list->value;//save the value of the last copied element.
	temp.add(list->value);
	while (list != NULL)
	{
		if (list->value != flag)
		{
			temp.add(list->value);
			flag = list->value;
		}
		if (list != NULL)
			list = list->next;
	}
	temp.reverse();
	lst = temp;
	return lst;
}

List.h:
[code]
#pragma once
#include <iostream>
using namespace std;

//------------------------------------------------
//  class List
//      arbitrary size Lists
//      permits insertion and removal 
//      only from the front of the List
//------------------------------------------------
class List
{
	private:
	//--------------------------------------------
	//  inner class link
	//  a single element for the linked List 
	//--------------------------------------------
	class Link
	{
	public:
		// constructor
		Link(int linkValue, Link *nextPtr);
		Link (const Link &);
		// data areas
		int value;
		Link * next;
	};	

	public:
	Link* head;
	// constructors
	List();
	List(const List&); 
	~List(); 
	
	// operations
	void add( int value);
	int firstElement() const;
	bool search(const int &value) const;
	bool isEmpty() const;
	void removeFirst();
	void print() const;
	void operator=(const List& other);
	void clear();
	void insert(int);
	void remove(int);
	void reverse();

	friend ostream &operator<<(ostream &out, List &myList);
	friend istream &operator>>(istream &in, List &myList);

	friend List merge(List, List);
	friend List makeSet(List&);

};

And the main is very simple...

Thanks!!

[Moschops]

And the main is very simple...

So simple that you think we can guess what it is?

I think that its compiler is Code Blocks,

That's not a compiler. If you're going to write programs, you need to be able to use the right words to describe things, otherwise other people won't understand you. http://www.cplusplus.com/articles/o8TbqMoL/

[NOvadia]

Any way my code is long, so I didn't want to add another code that not necessary (the pronlem is not there...)

main.cpp

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


int main()
{
	List lst1, lst2, mergedList;

	cout << "enter sorted values for the first list:" << endl;
	cin >> lst1;
	cout << "enter sorted values for the second list:" << endl;
	cin >> lst2;

	mergedList = merge(lst1, lst2);
	cout << "the new merged list: " << mergedList << endl;

	makeSet(mergedList);
	cout << "the new merged set: " << mergedList << endl;

	return 0;
}

Because I wasn't sure what the compiler is, I have written in brackets, and I said what I use (visual studio..) , and for another help what else happened to me (In the moodle..)


Thanks!

About this article, so after that I tried to figure out which compiler Moodle uses but not realized...

[Moschops]

enter sorted values for the first list:
1
10
20
30
40
50
60
70
0
enter sorted values for the second list:
11
23
33
43
53
63
0
the new merged list: 1 10 11 20 23 30 33 40 43 50 53 60 63 70 
the new merged set: 1 10 11 20 23 30 33 40 43 50 53 60 63 70 

Code works fine. No memory problems in it.

	makeSet(mergedList);
	cout << "the new merged set: " << mergedList << endl;

This looks wrong, though

[Chervil]

Instead of taking input from std::cin, I changed main to read from a file.

    std::ifstream fin1("data1.txt");
    fin1 >> lst1;

My file contained 20 integers in ascending order.

The program never terminates, there's an infinite loop during that input operation.

The question though is what input does the moodle test use?

[Moschops]

Aye, it does rely on the values of the input in order to stop waiting for input, in a way that's not very clear from the code.

[NOvadia]

Hey,

The moodle's values:
Test 1:
1 3 5 1
2 4 1
--- Expected output (text)---
enter sorted values for the first list:
enter sorted values for the second list:
the new merged list: 1 2 3 4 5
the new merged set: 1 2 3 4 5

Test 2:
--- Input ---
1 3 5 1
6 8 1
--- Expected output (text)---
enter sorted values for the first list:
enter sorted values for the second list:
the new merged list: 1 3 5 6 8
the new merged set: 1 3 5 6 8

Test 3:
--- Input ---
3 5 1
1 2 1
--- Expected output (text)---
enter sorted values for the first list:
enter sorted values for the second list:
the new merged list: 1 2 3 5
the new merged set: 1 2 3 5

Test 4:
--- Input ---
1 2 3 4 1
0 2 4 5 1
--- Expected output (text)---
enter sorted values for the first list:
enter sorted values for the second list:
the new merged list: 0 1 2 2 3 4 4 5
the new merged set: 0 1 2 3 4 5

I really do not know what values ​​you use ... Anyway for me it works fine, including the moodle's values. (except for the problem above.. )

Moschops, I don't understand..

Thanks!

[Moschops]

How does the program know when you have stopped typing in inputs?

I'm saying that's difficult to pick out from the code, and code that the reader cannot understand is bad code.

[NOvadia]

The program knows when entering an element which is smaller then the previous one..

About the code... Your'e right!
We got the base on which we needed to add functions..

[Chervil]

Anyway for me it works fine, including the moodle's values.

Does that mean the problem is now resolved?

(except for the problem above.. )

I thought there were TWO problems above.
1. your program didn't (apparently) terminate correctly.
2. the moodle automated testing gave an "Out of memory" error.

We got the base on which we needed to add functions..

Though I wouldn't rule out the possibility of problems in any part of the code, it could be useful to state which parts were provided, and which parts you had to write yourself. (that's if there is still a problem).

[NOvadia]

Works fine, i.e as it was at the begining, if I run it with a break point works good... but there is probably (as you say) a run time error.. and I guess that the problem in visual and moodle is the same one... (because there is no other problem in sight).

The part of the code that I wrote is from reverse function (including) and below...

The reason that I didn't mention it because even when I put all my code as a comment (and in the main almost all the code...) it still closing my program.

So I guess that the problem is not on in my part.... but now it hit me where should focus on, although I have no clue..

(And about what did my friends, they got another code..)

Thanks!

[naraku9333]

In VS to prevent the console window from closing after executing when running with ctrl+F5 the project subsystem needs to be set to console: Project Properties -> Linker -> System set subsystem to console for all configurations.

[NOvadia]

But it must be the same all the times...
because only in this code it was close and the other is left open, so it means that the issue is here.