STL Link List Problem

[cplusplusquestion]

#include <iostream>
#include <list>

using namespace std;

struct Cell{
list<intvertices;
bool counted;
Cell* nextCell;
Cell(){
counted=false;
nextCell=NULL;
}
~Cell(){
Cell* tmp = nextCell;
Cell* current_ptr = nextCell;
while(tmp != NULL){
current_ptr = current_ptr->nextCell;
delete tmp;
tmp = current_ptr;
}
}
};

int main(){
Cell* a = new Cell;
Cell* b = new Cell;
Cell* c = new Cell;
a->nextCell = b;
b->nextCell = c;
delete a;
return 0;
}

It compiles, but run the program, gets segmentation fault. If there is
no list<intvertices, it will be fine. Or if no coding in destructor
and keep list<intvertices, it's no problem too. Any idea?

[Barry]

cp***************@gmail.com wrote:

#include <iostream>
#include <list>

using namespace std;

struct Cell{
list<intvertices;
bool counted;
Cell* nextCell;
Cell(){
counted=false;
nextCell=NULL;
}
~Cell(){
Cell* tmp = nextCell;
Cell* current_ptr = nextCell;
while(tmp != NULL){
current_ptr = current_ptr->nextCell;
delete tmp;

free(tmp);

calling delete will recursively call you ~Cell() and
std::vector<int>::~vector()

tmp = current_ptr;
}
}
};

int main(){
Cell* a = new Cell;
Cell* b = new Cell;
Cell* c = new Cell;
a->nextCell = b;
b->nextCell = c;
delete a;
return 0;
}

It compiles, but run the program, gets segmentation fault. If there is
no list<intvertices, it will be fine. Or if no coding in destructor
and keep list<intvertices, it's no problem too. Any idea?

so you're destructing vertices more than once within one Cell

std::vector<inthelping detect the error

--
Thanks
Barry

[Barry]

Barry wrote:

cp***************@gmail.com wrote:

>#include <iostream>
#include <list>

using namespace std;

struct Cell{
list<intvertices;
bool counted;
Cell* nextCell;
Cell(){
counted=false;
nextCell=NULL;
}
~Cell(){
Cell* tmp = nextCell;
Cell* current_ptr = nextCell;
while(tmp != NULL){
current_ptr = current_ptr->nextCell;
delete tmp;

free(tmp);

calling delete will recursively call you ~Cell() and
std::vector<int>::~vector()

> tmp = current_ptr;
}
}
};

int main(){
Cell* a = new Cell;
Cell* b = new Cell;
Cell* c = new Cell;
a->nextCell = b;
b->nextCell = c;
delete a;
return 0;
}

It compiles, but run the program, gets segmentation fault. If there is
no list<intvertices, it will be fine. Or if no coding in destructor
and keep list<intvertices, it's no problem too. Any idea?

so you're destructing vertices more than once within one Cell

std::vector<inthelping detect the error

sorry, list<int>
and moreover, if use *free* other than *delete*, then /vertices/ won't
be destructed, which causes memory leak

--
Thanks
Barry

[cplusplusquestion]

On Sep 5, 9:06 pm, Barry <[e-mail]:

Barry wrote:

[e-mail] wrote:

#include <iostream>
#include <list>

using namespace std;

struct Cell{
list<intvertices;
bool counted;
Cell* nextCell;
Cell(){
counted=false;
nextCell=NULL;
}
~Cell(){
Cell* tmp = nextCell;
Cell* current_ptr = nextCell;
while(tmp != NULL){
current_ptr = current_ptr->nextCell;
delete tmp;

free(tmp);

calling delete will recursively call you ~Cell() and
std::vector<int>::~vector()

tmp = current_ptr;
}
}
};

int main(){
Cell* a = new Cell;
Cell* b = new Cell;
Cell* c = new Cell;
a->nextCell = b;
b->nextCell = c;
delete a;
return 0;
}

It compiles, but run the program, gets segmentation fault. If there is
no list<intvertices, it will be fine. Or if no coding in destructor
and keep list<intvertices, it's no problem too. Any idea?

so you're destructing vertices more than once within one Cell

std::vector<inthelping detect the error

sorry, list<int>
and moreover, if use *free* other than *delete*, then /vertices/ won't
be destructed, which causes memory leak

--
Thanks
Barry

Thanks! Does that mean I need to malloc() for each object instead of
new?

[Barry]

cp***************@gmail.com wrote:

>
Thanks! Does that mean I need to malloc() for each object instead of
new?

In your case, no, as it works fine

But your code is just some toy, I guess,
It's better to use new/delete malloc/free in pair, so if you need
list<intor something like that (none POD), then you have to use
new/delete instead of malloc/free.

In a word, redesign. get yourself a C++ book, there must be a LinkedList
in it.
--
Thanks
Barry

[Kai-Uwe Bux]

cp***************@gmail.com wrote:

On Sep 5, 9:06 pm, Barry <[e-mail]:

>Barry wrote:

[e-mail] wrote:
#include <iostream>
#include <list>

>using namespace std;

>struct Cell{
list<intvertices;
bool counted;
Cell* nextCell;
Cell(){
counted=false;
nextCell=NULL;
}
~Cell(){
Cell* tmp = nextCell;
Cell* current_ptr = nextCell;
while(tmp != NULL){
current_ptr = current_ptr->nextCell;
delete tmp;

free(tmp);

calling delete will recursively call you ~Cell() and
std::vector<int>::~vector()

> tmp = current_ptr;
}
}
};

>int main(){
Cell* a = new Cell;
Cell* b = new Cell;
Cell* c = new Cell;
a->nextCell = b;
b->nextCell = c;
delete a;
return 0;
}

>It compiles, but run the program, gets segmentation fault. If there is
no list<intvertices, it will be fine. Or if no coding in destructor
and keep list<intvertices, it's no problem too. Any idea?

so you're destructing vertices more than once within one Cell

std::vector<inthelping detect the error

sorry, list<int>
and moreover, if use *free* other than *delete*, then /vertices/ won't
be destructed, which causes memory leak

--
Thanks
Barry

Thanks! Does that mean I need to malloc() for each object instead of
new?

No, it means you have to fix the code in the destructor. Try:

~Cell(){
delete nextCell;
}
Best

Kai-Uwe Bux