title: How to fix signal SIGSEGV, Segmentation fault
body: <p>I'm getting an error message in Codeblocks C++ 'Program received signal SIGSEGV, Segmentation fault' in comparison between a vector element and a size of vector of vectors inside for loop (line 133 <code>if (parz_przestrzenie[i] != parz_dystanse[i].size())</code>).</p>
  <p>Could anyone tell me why?</p>
  <pre><code>#include &lt;iostream&gt;
  #include &lt;vector&gt;
  #include &lt;algorithm&gt;
  using namespace std;
  
  int bloki_parz[100000], bloki_nieparz[100000];
  
  int silnia(int n)
  {
      int liczba = 1;
      for (int i = 1; i &lt;= n; i++)
      {
          liczba *= i;
      }
      return liczba;
  }
  
  int main()
  {
      int n, czapka, wolne_miejsca = 0, wynik = 1;
      vector&lt;int&gt; parz, nieparz, parz_przestrzenie, nieparz_przestrzenie, parz_przestrzenie2, nieparz_przestrzenie2;
      vector&lt;vector&lt;int&gt;&gt; parz_dystanse;
      vector&lt;vector&lt;int&gt;&gt; nieparz_dystanse;
  
      cin &gt;&gt; n;
      for (int i = 1; i &lt;= n; i++)
      {
          cin &gt;&gt; czapka;
          if (i % 2 == 0)
          {
              parz.push_back(czapka);
          }
          else
          {
              nieparz.push_back(czapka);
          }
      }
      int parz_size = parz.size(), nieparz_size = nieparz.size();
      // sprawdzamy czy dane nie sÂą sprzeczne ; gdy zabraknie nam miejsc do rozmieszczania
      vector&lt;int&gt; parz_duplicate = parz;
      vector&lt;int&gt; nieparz_duplicate = nieparz;
      parz_duplicate.erase(unique(parz_duplicate.begin(), parz_duplicate.end()), parz_duplicate.end());
      nieparz_duplicate.erase(unique(nieparz_duplicate.begin(), nieparz_duplicate.end()), nieparz_duplicate.end());
      int parz_dupl_size = parz_duplicate.size(), nieparz_dupl_size = nieparz_duplicate.size();
  
      if (parz_size &lt; nieparz_dupl_size)
      {
          cout &lt;&lt; 0 &lt;&lt; endl;
          return 0;
      }
      if (nieparz_size &lt; parz_dupl_size)
      {
          cout &lt;&lt; 0 &lt;&lt; endl;
          return 0;
      }
  
      for (int i = 0; i &lt; parz_size - 1; i++)
      {
          if (parz[i] == parz[i + 1])
          {
              bloki_parz[i + 1] = 1;
          }
      }
      for (int i = 0; i &lt; nieparz_size - 1; i++)
      {
          if (nieparz[i] == nieparz[i + 1])
          {
              bloki_nieparz[i] = 1;
          }
      }
  
      for (int i = 0; i &lt; parz_size; i++)
      {
          vector&lt;int&gt; bloczek;
          for (int j = i; j &lt; parz_size; j++)
          {
              if (parz[j] != parz[j + 1])
              {
                  bloczek.push_back(parz[j]);
              }
              else
              {
                  i += 1;
                  break;
              }
          }
          if (bloczek.size() != 0)
          {
              parz_dystanse.push_back(bloczek);
          }
      }
      int parz_dyst_size = parz_dystanse.size();
      if (parz[parz_size - 1] != parz[parz_size - 2])
      {
          parz_dystanse[parz_dyst_size - 1].push_back(parz[parz_size - 1]);
      }
  
      for (int i = 0; i &lt; nieparz_size; i++)
      {
          vector&lt;int&gt; bloczek;
          for (int j = i; j &lt; nieparz_size; j++)
          {
              if (nieparz[j] != nieparz[j + 1])
              {
                  bloczek.push_back(nieparz[j]);
              }
              else
              {
                  i += 1;
                  break;
              }
          }
  
          if (bloczek.size() != 0)
          {
              nieparz_dystanse.push_back(bloczek);
          }
      }
  
      int nieparz_dyst_size = nieparz_dystanse.size();
  
      int current_wynik = 0;
      for (int i = 0; i &lt; nieparz_size; i++)
      {
          if (bloki_parz[i] == 0)
          {
              current_wynik++;
          }
          else
          {
              if (current_wynik != 0)
              {
                  parz_przestrzenie.push_back(current_wynik);
              }
              current_wynik = 0;
          }
      }
      parz_przestrzenie.push_back(current_wynik);
  
      current_wynik = 0;
      for (int i = 0; i &lt; parz_size; i++)
      {
          if (bloki_nieparz[i] == 0)
          {
              current_wynik++;
          }
          else
          {
              if (current_wynik != 0)
              {
                  nieparz_przestrzenie.push_back(current_wynik);
              }
              current_wynik = 0;
          }
      }
      nieparz_przestrzenie.push_back(current_wynik);
  
      int parz_przest_size = parz_przestrzenie.size(), nieparz_przest_size = nieparz_przestrzenie.size();
  
      for (int i = 0; i &lt; 1; i++)
      {
          if (parz_przestrzenie[i] != parz_dystanse[i].size())
          {
              wynik *= parz_przestrzenie[i];
              wolne_miejsca++;
          }
      }
      for (int i = 0; i &lt; nieparz_przest_size; i++)
      {
          if (nieparz_przestrzenie[i] != nieparz_dystanse[i].size())
          {
              wynik *= nieparz_przestrzenie[i];
              wolne_miejsca++;
          }
      }
  
      cout &lt;&lt; wynik * silnia(wolne_miejsca) &lt;&lt; endl;
  }
  </code></pre>