Błąd w nowo wygenerowanej tablicy

Witam, mam problem, polecenie brzmi:
"Napisz funkcję zwracającą tablicę powiększoną o dodatkowe k elementów (parametr funkcji) równych 0. Wszystkie potrzebne dane funkcja pobiera jako parametry. "

Powinno wyswietlac:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
A następnie nową tablicę z ilością zer podanych w parametrach funkcji
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 0 0 0

Program pisałem modyfikując inny

Napisałem takie cos:

# include <iostream>
# include <cstdlib>
# include <conio.h>

using namespace std;

void wstaw (int x, int y, int *tab, int &rozmiar);

int main ()
{
int rozmiar = 20;
int *tab = new int[rozmiar];

for (int a = 0; a < rozmiar; a++)
{
	tab[a] = a;
	cout  <<tab[a] << " ";
}
//cout<< rozmiar;	
wstaw (0, 20, tab, rozmiar);
cout<< endl;


for (int a = 0; a < rozmiar; a++)
    {
    cout << tab[a] << " ";
    }

getch ();
return 0;
}


void powieksz (int powieksz_k, int *tab, int &rozmiar)
{
int *nowa_tab = new int[rozmiar + powieksz_k];
for (int n = 0; n < rozmiar; n++)
   {
    nowa_tab[n] = tab[n];
   }
    
    

rozmiar += powieksz_k;
}

void wstaw (int x, int y, int *tab, int &rozmiar)
{
powieksz(4, tab, rozmiar); //tutaj podaje o ile elementow ma powiekszyc tablice
//tab[y] = x;
} 

Ma ktoś pomysł co jest nie tak?

W funkcji powieksz ustawiasz jedynie pierwsze rozmiar elementów, podczas gdy alokujesz rozmiar + powieksz_k.

Btw, żyjemy w XXI wieku - nie oszczędzaj na nazwach identyfikatorów:

void powiekszTablice(size_t oIlePowiekszyc, int* tablica, size_t& aktualnyRozmiar)

i już wiadomo co z czym.

Przepraszam ale już się pogubiłem z tym.
Wyświetla:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 0 -1986463623 469777649

# include <iostream>
# include <cstdlib>
# include <conio.h>

using namespace std;

void wstaw (int x, int y, int * tablica, int &rozmiar);

int main ()
{
int rozmiar = 20;
int *tab = new int[rozmiar];

for (int a = 0; a < rozmiar; a++)
{
	tab[a] = a;
	cout  <<tab[a] << " ";
}
//cout<< rozmiar;	
wstaw (0, 20, tab, rozmiar);
cout<< endl;


for (int a = 0; a < rozmiar; a++)
    {
    cout << tab[a] << " ";
    }

getch ();
return 0;
}

void powiekszTablice(size_t oIlePowiekszyc, int* tablica, int& aktualnyRozmiar)
{
int *nowa_tab = new int[aktualnyRozmiar + oIlePowiekszyc];
for (int n = 0; n < aktualnyRozmiar; n++)
   {
    nowa_tab[n] = tablica[n];
   }
    
    

aktualnyRozmiar += oIlePowiekszyc;
}

void wstaw (int x, int y, int *tablica, int &rozmiar)
{
powiekszTablice(4, tablica, rozmiar);
//tab[y] = x;
} 

Po pierwsze formatter: http://format.krzaq.cc

Po drugie po co y?

void wstaw (int x, int y, int *tab, int &rozmiar)

A główny problem masz w tym, że tworzysz nowa_tab, a potem nigdzie tego nie zapisujesz, więc dostęp do tej pamięci umrze śmiercią naturalną po wyjściu z funkcji. Pamięć nadal istnieje (wyciek!), ale już nie masz żadnego wskaźnika, który by wskazał na nią.
A dostajesz śmieci bo wypisujesz wartości ze starej tablicy, przy okazji wychodząc poza jej zakres.

A jako bonus: gdzie dopisujesz te zera? Zera same się nie dopisują.

W sumie można skroić takie coś:

#include<iostream>
#include<algorithm>
using namespace std;

int* addElements(int *array, unsigned length, unsigned elementsCount){
    int *resized = new int[length + elementsCount];
    copy(array,array+length,resized);
    fill(resized+length,resized+length+elementsCount,0);
    return resized;
}

int main(){
    int first[] { 1, 2 };
    size_t size = sizeof(first)/sizeof(first[0]);
    int *second = addElements(first,size,4);

    for(unsigned i=0;i<size+4;++i) cout << second[i] << endl;
    delete[] second;
    return 0;
}

@grzesiek51114 fakt faktem działa, lecz nie jestem w stanie wytłumaczyć dlaczego i jak to działa a na tym mi najbardziej zależy (wykładowca wymaga)
@twonek z pamięcią męczyłem się na zajęciach właśnie wraz z wykładowcą, lecz przyznam szczerze, że jestem zielony w te klocki
Dziękuję wszystkim za wskazówki, będę próbował jakoś to ogarnąć.

Może trochę bardziej klasycznie:

#include<iostream>
#include<algorithm>
using namespace std;

int* addElements(int *array, unsigned length, unsigned elementsCount){
    
    //  Tworzenie nowej tablicy.
    //  Tablica dynaniczna, ponieważ jej rozmiar określamy w trakcie działania programu.
    int *resized = new int[length + elementsCount];
    
    //  Przepisujemy wszystkie elementy z tablicy małej do powiększonej.
    for(unsigned i=0;i<length;++i){
        resized[i]=array[i];
    }

    //  Uzupełniamy puste miejsca w powiększonej tabelicy zerami.
    for(unsigned i=length;i<length+elementsCount;++i){
        resized[i]=0;
    }
    
    //  Zwracamy wskaźnik na nowo utworzoną tablicę.
    //  Jest to obiekt alokowany na stercie więc klamry nas nie ograniczają
    //  i będzie on istniał po zakończeniu funkcji. Dysponujemy wskaźnikiem
    //  do tego obiektu i ten właśnie wskaźnik zwracamy.
    return resized;
}

int main(){
    int first[] { 1, 2 };
    size_t size = sizeof(first)/sizeof(first[0]);
    int *second = addElements(first,size,4);

    for(unsigned i=0;i<size+4;++i) cout << second[i] << endl;
    
    //  Ponieważ większa tablica jest alokowana dynamicznie na stercie
    //  należy ją ręcznie z pamięci usunąć.
    delete[] second;
    return 0;
}

To już jest zrozumiałe :)
Niestety wszystkie potrzebne dane funkcja pobiera jako parametry - takie mam wymagania niestety