Databases
StackOverflow2013
Postsdbo
POSegmentation fault at the end of the program
 

Note that there are some explanatory texts on larger screens.

plurals
  1. POSegmentation fault at the end of the program
    primarykey
    data
    text
    <p>I have a segmentation fault problem occurring at the very end of my program. Everything works as expected except for the sole error message. And the one appears only if I choose the second option from my menu (see menu.cpp below) which calls for one graph class method (see in Graf.cpp - "odszukaj_dfs"). After completing all tasks it exits with an above mentioned error. This means my error occurs only if during my session I use this method, hoverer just after I safely exit my session through menu option #4, regardless of what has been done in between (which menu options invoked) those two calls.</p> <p>I would appreciate for any hint on what is wrong. Please let me know if you need more pieces of my code to solve it, I didn't post all of it in order not to make my post too bloated. Secondly, forgive for not using English in my code - the project is for my University and I had to stick to my native tongue. Thank you in advance.</p> <p>As to what the program itself is to do - it is to read a graph from a file and be able to perform a depth-first search on it. The problem occurs while doing the latter.</p> <pre><code>//main.cpp #include &lt;iostream&gt; #include "wczytywanie_grafu/wczytaj_nazwe_pliku.h" #include "wczytywanie_grafu/wczytaj_graf.h" #include "menu/menu.h" #include "graf_struktura/Graf.h" int main( int argc, char *argv[] ) { using namespace std; const char* npliku = wczytaj_nazwe_pliku( argc, argv ); if( npliku != 0 ) { Graf *g = poprosze_graf(npliku); while( menu(*g) ); delete g; } cout &lt;&lt; "Do widzenia.\n"; return 0; } </code></pre> <p>Here is where the problem occurs:</p> <pre><code>//menu.cpp #include "menu.h" #include &lt;iostream&gt; //wyswietla menu dostepnych operacji na poprawnie wczytanym grafie. bool menu(Graf &amp;g) { using namespace std; int i; char *token; cout &lt;&lt; endl; cout &lt;&lt; "Jaka operacje wykonac na wczytanym grafie?\n"; cout &lt;&lt; endl; cout &lt;&lt; "1) Wyswietlic schemat.\n"; cout &lt;&lt; "2) Wyszukac wierzcholek metoda DFS.\n"; cout &lt;&lt; "3) Wczytac inny graf.\n"; cout &lt;&lt; "4) Opuscic program.\n"; cout &lt;&lt; endl; cout &lt;&lt; "Prosze o wybor jednej z powyzszych opcji. "; while( !(cin &gt;&gt; i) || i &lt; 1 || i &gt; 4 ) { cin.clear(); cin.ignore(1000, '\n'); cout &lt;&lt; "\nBlad. Prosze podac desygnujaca odpowiedz liczbe z podanego zakresu. "; } cout &lt;&lt; endl; switch( i ) { case 1 : g.wyswietl(); break; case 2 : cout &lt;&lt; "Prosze podac nazwe szukanego wierzcholka. "; cin &gt;&gt; token; cout &lt;&lt; "Odwiedzone wierzcholki: "; if( g.odszukaj_dfs(token) == 0 ) cout &lt;&lt; "\nNie odnaleziono wierzcholka " &lt;&lt; token &lt;&lt; ".\n"; else cout &lt;&lt; "\nOdnaleziono wierzcholek " &lt;&lt; token &lt;&lt; ".\n"; break; // case 3 : // // break; case 4 : return false; } return true; } </code></pre> <p>Here are the graph definitions ("Graf" is for graph and "Wierzcholek" for its node)</p> <pre><code>//Graf.cpp #include "Graf.h" #include "../lifo/TabDyn.h" #include "../lifo/Stos.h" #include &lt;cstring&gt; /*###########################################################*/ /*####################### WIERZCHOLEK #######################*/ /*###########################################################*/ /*konstruktory*/ Wierzcholek::Wierzcholek(void) { sasiedztwo = -1; nastepny = poprzedni = 0; sasiedzi = new Wierzcholek* [1*sizeof(Wierzcholek*)]; } Wierzcholek::Wierzcholek(char* k) { klucz = k; //wierzcholek izolowany grafu. sasiedztwo = 0; nastepny = poprzedni = 0; sasiedzi = new Wierzcholek* [1*sizeof(Wierzcholek*)]; } Wierzcholek::Wierzcholek(char* k, int s) { klucz = k; sasiedztwo = s; nastepny = poprzedni = 0; //przygotowanie tablicy sasiadow o stosownym rozmiarze sasiedzi = new Wierzcholek* [s*sizeof(Wierzcholek*)]; } Wierzcholek::Wierzcholek(char* k, int s, Wierzcholek** &amp;n) { //typowy wierzcholek grafu. klucz = k; sasiedztwo = s; sasiedzi = n; nastepny = poprzedni = 0; } Wierzcholek::Wierzcholek(char* k, int s, Wierzcholek** &amp;n, Wierzcholek* &amp;nast , Wierzcholek* &amp;poprz) { //typowy wierzcholek grafu. klucz = k; sasiedztwo = s; sasiedzi = n; nastepny = nast; poprzedni = poprz; } /*przeciazenia i metody*/ //relacja rownowaznosci obiektow oparta na identycznosci kluczy bool Wierzcholek::operator==(Wierzcholek const &amp;prawy) const { if ( klucz == prawy.klucz ) return true; else return false; } void Wierzcholek::okresl_ilosc_sasiadow(int n) { delete [] sasiedzi; sasiedzi = new Wierzcholek* [n*sizeof(Wierzcholek)]; sasiedztwo = n; } /*###########################################################*/ /*########################### GRAF ##########################*/ /*###########################################################*/ /*konstruktor*/ Graf::Graf(void) { pierwszy = ostatni = 0; rozmiar = 0; } /*metody*/ void Graf::dodaj(Wierzcholek* w) { if ( pierwszy != 0 ) { w-&gt;poprzedni = ostatni; ostatni = w; ostatni-&gt;poprzedni-&gt;nastepny = ostatni; } else pierwszy = ostatni = w; ostatni-&gt;pozycja = rozmiar++; } void Graf::wyswietl(void) { using namespace std; Wierzcholek *n = pierwszy; for( int j=0; j &lt; rozmiar; n = n-&gt;nastepny) { cout &lt;&lt; n-&gt;klucz &lt;&lt; " :"; for( int i=0; i &lt; n-&gt;sasiedztwo; i++ ) cout &lt;&lt; " " &lt;&lt; n-&gt;sasiedzi[i]-&gt;klucz; cout &lt;&lt; " ;\n"; j++; } return; } int Graf::podaj_rozmiar(void) { return rozmiar; } Wierzcholek* Graf::odszukaj_dfs(char* &amp;klucz) { using namespace std; //tablica przyporzadkowujaca kazdemu kolejnemu wierzcholkowi grafu //binarna wartosc oznaczajaca fakt odwiedzenia wierzcholka przez algorytm. TabDyn&lt;bool&gt; odwiedzony; for(int i=0; i &lt; rozmiar; i++) odwiedzony.dodaj(0); //stos wierzcholkow sasiadujacych z juz odwiedzonymi wierzcholkami. Stos&lt; Wierzcholek* &gt; stos; //wierzcholek zdjety ze stosu. Wierzcholek* biezacy = pierwszy; //kolejny wierzcholek ciagu wierzcholkow grafu, //uwzgledniony, aby nie pominac wierzcholkow izolowanych. Wierzcholek* numerowany = pierwszy; //zmienna pomocnicza stworzona dla przejrzystosci kodu //wierzcholek sasiadujacy z biezacym //dokladany na stos, jezeli nie zostal jeszcze odwiedzony. Wierzcholek* sasiad = 0; //elementow grafu jest dokladnie "rozmiar". for( int i=0; i &lt; rozmiar; i++, numerowany=numerowany-&gt;nastepny ) { cout &lt;&lt; "plus: " &lt;&lt; numerowany-&gt;klucz &lt;&lt; endl; if( odwiedzony[numerowany-&gt;pozycja] ) continue; stos.doloz( numerowany ); while( !stos.jest_pusty() ) { biezacy = stos.zdejmij(); if ( odwiedzony[biezacy-&gt;pozycja] ) continue; else odwiedzony[biezacy-&gt;pozycja] = true; if( strcmp(biezacy-&gt;klucz, klucz) == 0 ) { cout &lt;&lt; endl; return biezacy; } //sasiadow jest dokladnie "sasiedztwo". for( int j=0; j &lt; biezacy-&gt;sasiedztwo; j++) { sasiad = biezacy-&gt;sasiedzi[j]; if( !odwiedzony[sasiad-&gt;pozycja] ) stos.doloz(sasiad); } } } cout &lt;&lt; endl; return 0; } </code></pre> <p>Here are the files for Stack (here as "Stos") and Dynamically Allocated Table (here as "TabDyn")</p> <pre><code>#ifndef STOS_H #define STOS_H template&lt;typename T&gt; class TabDyn; template&lt;typename T&gt; class Stos { private: /*pola*/ TabDyn&lt;T&gt;* pula; public: /*konstruktory*/ Stos(void); Stos(int); ~Stos(void); /*metody*/ void wyczysc(void); bool jest_pusty(void) const; T&amp; top(void); T zdejmij(void); void doloz(const T&amp;); }; #include "Stos.tcc" #endif //Stos.tcc #ifndef STOS_TCC #define STOS_TCC #include "TabDyn.h" template&lt;typename T&gt; Stos&lt;T&gt;::Stos(void) { pula = new TabDyn&lt;T&gt;; } template&lt;typename T&gt; Stos&lt;T&gt;::Stos(int rozmiar) { pula = new TabDyn&lt;T&gt;(rozmiar); } template&lt;typename T&gt; Stos&lt;T&gt;::~Stos(void) { delete pula; } template&lt;typename T&gt; void Stos&lt;T&gt;::wyczysc(void) { pula-&gt;wyczysc(); } template&lt;typename T&gt; bool Stos&lt;T&gt;::jest_pusty(void) const { return pula-&gt;jest_pusty(); } template&lt;typename T&gt; T&amp; Stos&lt;T&gt;::top(void) { return pula-&gt;koniec(); } template&lt;typename T&gt; T Stos&lt;T&gt;::zdejmij(void) { //nalezy uprzednio sprawdzic czy stos nie jest pusty! T el = pula-&gt;koniec(); pula-&gt;usun(); return el; } template&lt;typename T&gt; void Stos&lt;T&gt;::doloz(const T&amp; el) { pula-&gt;dodaj( el ); } #endif //TabDyn.h #ifndef TABDYN_H #define TABDYN_H using namespace std; int const STD_ROZMIAR = 50; /*###########################################################*/ template&lt;typename T&gt; class TabDyn { private: /*pola*/ int max_rozmiar; int akt_rozmiar; T *przydzial_pamieci; public: /*metody*/ TabDyn(int rozmiar = STD_ROZMIAR); T&amp; operator[](int i); //usuwa stary przydzial pamieci i nadaje nowy bool zarezerwuj(int); //chyba: wyjebac stary przydzial i przydzielic nowy void wyczysc(void); //sprawdzic akt_rozmiar bool jest_pusty(void); //wskaznik na poczatek plus akt_rozmiar T&amp; koniec(void); bool usun(void); //!!! pop_back // void doloz_nkoniec( const T&amp; ); //!!! push_back void dodaj( const T&amp; ); //!!! push_back }; #include "TabDyn.tcc" #endif //TabDyn.tcc #ifndef TABDYN_TPP #define TABDYN_TPP #include &lt;iostream&gt; /*###########################################################*/ template&lt;typename T&gt; TabDyn&lt;T&gt;::TabDyn(int rozmiar) { przydzial_pamieci = new T [rozmiar*sizeof(T)]; max_rozmiar = rozmiar; akt_rozmiar = 0; } template&lt;typename T&gt; T&amp; TabDyn&lt;T&gt;::operator[](int i) { if( i &gt;= 0 &amp;&amp; i &lt; akt_rozmiar ) { return *(przydzial_pamieci + i); } cout &lt;&lt; "Blad: Zarzadano wartosci tablicy dynamicznej spoza zakresu. Podano wartosc ostatniego elementu.\n"; return *(przydzial_pamieci + akt_rozmiar); } template&lt;typename T&gt; bool TabDyn&lt;T&gt;::zarezerwuj(int wolumen) { if ( max_rozmiar == wolumen ) return true; if ( wolumen &lt; akt_rozmiar ) { cout &lt;&lt; "Blad: Nowy zadany rozmiar tablicy dynamicznej nie jest w stanie pomiescic elementow, ktore juz sie w niej znajduja. Odmowa wykonania operacji. " &lt;&lt; endl; return false; } T *npamiec = new T [wolumen*sizeof(T)]; if ( ! jest_pusty() ) { for( int i=0; i &lt; akt_rozmiar; i++ ) { *(npamiec + i) = *(przydzial_pamieci + i); } } max_rozmiar = wolumen; delete [] przydzial_pamieci; przydzial_pamieci = npamiec; return true; } template&lt;typename T&gt; void TabDyn&lt;T&gt;::wyczysc(void) { delete [] przydzial_pamieci; przydzial_pamieci = new T [max_rozmiar*sizeof(T)]; } template&lt;typename T&gt; bool TabDyn&lt;T&gt;::jest_pusty(void) { return !akt_rozmiar; } //zwraca ostatni element tablicy template&lt;typename T&gt; T&amp; TabDyn&lt;T&gt;::koniec(void) { T&amp; ans = *(przydzial_pamieci + akt_rozmiar - 1); if( !akt_rozmiar ) std::cout &lt;&lt; "Blad, stos jest pusty.\n"; return ans; } //usuwa ostatni element tablicy template&lt;typename T&gt; bool TabDyn&lt;T&gt;::usun(void) { if ( akt_rozmiar == 0 ) { std::cout &lt;&lt; "Blad: Nie mam co usunac.\n"; return false; } akt_rozmiar--; return true; } //dodaje ostatni element tablicy template&lt;typename T&gt; void TabDyn&lt;T&gt;::dodaj( const T&amp; el ) { if ( akt_rozmiar + 1 &gt; max_rozmiar ) { cout &lt;&lt; "Uwaga: przekroczono rozmiar tablicy dynamicznej. Zostanie przydzielona nowa wielkosc." &lt;&lt; endl; zarezerwuj(max_rozmiar+1); } *(przydzial_pamieci + akt_rozmiar++) = el; } #endif </code></pre>
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. USinfoholic_anonymous
    1. USinfoholic_anonymous
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. PO
      singulars
      1. PTAnswer
    1. VO
      singulars
      1. POSegmentation fault at the end of the program
      1. This table or related slice is empty.
      1. VTDownMod
    1. COThis is the only question I've seen on SO where Google Translate has come up and offered to translate the code.
      singulars
      1. POSegmentation fault at the end of the program
      1. USchris
    2. COAsking strangers to spot errors in your code by inspection is not productive. You should identify (or at least isolate) the problem by using a debugger or print statements, and then come back with a more specific question (once you've narrowed it down to a 10-line [test-case](http://sscce.org)).
      singulars
      1. POSegmentation fault at the end of the program
      1. USOliver Charlesworth
    3. CO@chris: Haha I was just about to leave the same comment.
      singulars
      1. POSegmentation fault at the end of the program
      1. USEd S.
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload