Deleting a pointer reference crashes the program - c++

Question

I'm learning cpp by myself (I hope I didn't scare you off already), I understand what a pointer or a reference is and I think I get what a reference to a pointer is.
I've written a code that crashes at delete[] ranking; :
open(file) is just a simple function to open a txt file that contains a string and 3 integers each line which goes into zuzel structure:
void read_file(std::ifstream & file, zuzel *& ranking)
{
if(!open(file))
return; //exit function if reading a file failed
int size = 1;
while(!file.eof())
{
zuzel * update = new zuzel[size];
if(ranking != NULL) memcpy(update, ranking, (size-1)*sizeof(*ranking)); //copy existing contents
file >> update[size - 1].nazwa >> update[size - 1].zawodnicy >> update[size - 1].mecze >> update[size - 1].punkty;// add a new team
delete[] ranking; //delete old data
std::cout << "tst"; //just to see if it crashes
ranking = update;
size++;
}
}
int main()
{
zuzel * rank;
std::ifstream file;
read_file(file, rank);
return 0;
}
I found out that you shouldn't delete something that you didn't new, but for example that code doesn't crash :
void funk(int *& a)
{
delete[] a;
}
int main()
{
int a[3] = {3, 4, 6};
int * p = a;
funk(p);
return 0;
}
How can I fix that crash? I'd be much obliged for some simple explanation why does it behave that way.

Answer 1

It will be enough to write
zuzel * rank = 0;
As for the second code snippet then it has undefined behaviour.

Answer 2

zuzel * rank;
//somewhere in read_file:
delete[] ranking; //ranking is a reference to pointer;
//in your case it's referernce to uninitialized pointer rank
Because rank is not initialized, it points to a unknown portion of memory, and your code simply tryes to delete[] the portion anyway...
You need to do set a pointer to address 0 by using one of these:
zuzel * rank=nullptr; //in C++11
zuzel * rank=NULL; //before C++11
zuzel * rank=0; //also legal, but I not recommend this
0 is the special value for any pointer, meaning that it points to nothing.
When you pass pointer set to 0 to delete[] or delete they simply do nothing.

Answer 3

Since you're learning. Please accept this example of how you might prefer to do it. You will find that it's exception-safe and avoids using pointers (and therefore avoids the need for memory management)
main.cpp:
#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <algorithm>
#include <iterator>
struct zuzel
{
std::string nazwa, zawodnicy, mecze, punky;
};
std::ostream& operator<<(std::ostream& os, const zuzel& z)
{
return os << z.nazwa << ", "
<< z.zawodnicy << ", "
<< z.mecze << ", "
<< z.punky;
}
std::vector<zuzel> read_zuzels(std::string filename)
{
std::vector<zuzel> results;
std::ifstream f(filename.c_str());
f.exceptions(std::ios::badbit);
while(!f.eof())
{
// add a new team
zuzel new_zuzel;
f >> new_zuzel.nazwa
>> new_zuzel.zawodnicy
>> new_zuzel.mecze
>> new_zuzel.punky;
results.push_back(new_zuzel);
}
return results;
}
using namespace std;
int main()
{
vector<zuzel> zuzels = read_zuzels("input.txt");
copy(zuzels.begin(), zuzels.end(), ostream_iterator<zuzel>(cout, "\n"));
return 0;
}
input.txt:
foo1 bar1 baz1 bazzer1
foo2 bar2 baz2 bazzer2
output:
Compiling the source code....
$g++ main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1
Executing the program....
$demo
foo1, bar1, baz1, bazzer1
foo2, bar2, baz2, bazzer2