void resize(size_t newSize){
		type* temp = new type[newSize];
			for(int i = 0 ; i < (sizeof(temp) / sizeof(temp[0])); i++){
				temp[i] = 0;
		}
			for(int i = 0 ; i < (sizeof(temp) / sizeof(temp[0])); i++){
				temp[i] = values[i];
		}
			delete[] values;
		    values = new type[newSize];
			for(int i = 0 ; i < (sizeof(values) / sizeof(values[0])) ; i++){
				 values[i] = temp[i];
		}
			size = newSize;
	}

Aber anscheinend ist etwas falsch da wenn ich danach mein Array neu ausgeben lasse kommen unrealistische Werte herraus

Wie sieht das ganze in richtig aus?

Fehler:
- Stil: Globale Variablen
- Fehler: sizeof(pointertyp) ist eben die Größe eines Pointers, nicht dessen, worauf er zeigt
- Stil: Nullsetzen kannst du auch im new
- Stil warum Nullsetzen, wenn du sofort mit anderen Werten überschreibst?
- Stil: Um drei Ecken gedacht: Erst neues temporäres Feld angelegt, dann Werte reinkopiert, dann neues Feld angelegt, dann Werte zurückkopiert. Warum nicht einfach dem alten Pointer das neue Feld zuweisen
- Stil: Und wenn eines der new eine Exception wirft? Dann fliegen deine alten Werte im Nirvana rum.
- Stil: Au weia! Das macht man einfach nicht so, mit der manuellen Speicherverwaltung. Das kapselt man sauber in Klassen, die sich an RAII halten. Dann kann auch nix mehr schiefgehen. Und die Kapselung von new[] kennt die Standardbibliothek schon. Nennt sich std::vector.

void resize( std::size_t newSize )
    {
        assert( newSize >= size );
        type* temp = new type[newSize];
        std::fill( std::copy( values, values + size, temp ), temp + newSize, type(0) );
        delete[] values;
        values = temp;
        size = newSize;
    }

.. wobei das nur für rudimentäre Typen Sinn macht

besser: nimm std::vector