Tablice dynamiczne, wskaźniki i lasery

Witam, taki kod jest:

#include <iostream>
using namespace std;
int main() //int argc, char** argv
{
	int *tab1 = new int();
	char *tab2 = new char();
	int a = 0;
	int b = 0;
	bool temp = true;

	do {
		cin >> *(tab1+a);  
		if(*(tab1+a) == 0) temp = false;
		a++;
		if(temp) {
			cin >> *(tab2+b);
			b++;
		}
	} while(temp);

	for(int i=0; i<b; i++) cout << *(tab1+i) << " " << *(tab2+i) << "\n";

	return 0;
}


 

Program ma wczytywać na przemian liczbę całkowitą i literkę aż natrafi na 0 (zero), potem coś z tym zrobić (to pomijam) i wypisać pary w osobnych wierszach. Czyli dla przykładu "61 r 64 a 56 v 25 v 54 n 56 e 8 y 93 c 82 f 57 b 0", powinienem otrzymać wynik:
61 r
64 a
56 v
25 v
54 n
56 e
8 y
93 c
82 f
57 b

Jednak takiego nie otrzymuję, tylko:
61 6
64
56
25
54 8
1668900152 e
25190 y
93 c
82 f
57 b

Dla innych przykładów są inne krzaki. Gdzie popełniam błąd? Czego brakuje?
P.S. Nie mogę użyć zwykłej tablicy.

U mnie ten program dziala i wyskakuja poprawne dane. Ale jak wpisuje caly ciag to przy ostatniej liczbie wyskakuje blad "zamknij program"
Jak wpisujesz te dane ?

W terminalu na Ubuntu, czasem odręcznie, a czasem wklejam.

Dla wskaźników tab1 i tab2 przydzielasz pamięć ale tylko na jeden element typu int/char?
Następnie przesuwasz się wskaźnikami i wczytujesz "gdzieś" w niezarezerwowaną do użytku pamięć kolejne pary. Jak chcesz się potem do nich dostać?

Nie wiesz jak długo będziesz wpisywał te pary cyferek i literek, czy będzie ich 10 czy 100. Dlatego musisz użyć czegoś, co przy każdym wczytaniu pary będzie rezerwowało na nią nową pamięć.

Użyj np. vector:

#include<vector>
...
std::vector<int> tab1;
int cyfra;
...
do {
    cin >> cyfra;
    tab1.push_back(cyfra);
    ...
while ( temp );

niby co to ma być: "new int();" lub "new char()"?
jaką wielkości mają te tablice?
Ewidentnie brak ci podstaw o alokacji tablic, ergo Grębosz do ręki.

Najprościej wczytać je za pomocą standardowej biblioteki vector, jeżeli chcesz już bawić się wskaźnikami to poczytaj np. o,liście jednokierunkowej

Main

#include <iostream>
#include "Stash.h"
using namespace std;

int main(){
    Stash intStash(sizeof(int));
    Stash stringStash(sizeof(unsigned char));
    int n = 1;
    char m;
    while(n != 0){
        cout << "Podaj liczbe: ";
        cin >> n;
        intStash.add(&n);
        cout << "Podaj literke: ";
        cin >> m;
        stringStash.add(&m);
    }
    for(int i =0;i<intStash.count();i++){
        cout << *reinterpret_cast<int*>(intStash.fetch(i)) << " ";
        cout << *reinterpret_cast<char*>(stringStash.fetch(i))<<endl;
    }
    return 0;
}

Stash.h

#ifndef STASH_H
#define STASH_H

class Stash {
  int size;      // Wielkosc kazdego elementu
  int quantity;  // Liczba elementow pamieci
  int next;      // Nastepny pusty element
  // Dynamicznie przydzielana tablica bajtow:
  unsigned char* storage;
  void inflate(int increase);
public:
  Stash(int size);
  ~Stash();
  int add(void* element);
  void* fetch(int index);
  int count();
};
#endif

Stash.cpp

#include "Stash.h"
#include <iostream>
using namespace std;
const int increment = 100;

Stash::Stash(int sz) {
  size = sz;
  quantity = 0;
  storage = 0;
  next = 0;
}

int Stash::add(void* element) {
  if(next >= quantity) // Czy wystarczy pamieci?
    inflate(increment);
  // Kopiowanie elementu do pamieci,
  // poczawszy od nastepnego wolnego miejsca:
  int startBytes = next * size;
  unsigned char* e = (unsigned char*)element;
  for(int i = 0; i < size; i++)
    storage[startBytes + i] = e[i];
  next++;
  return(next - 1); // Numer indeksu
}

void* Stash::fetch(int index) {
  if(index >= next)
    return 0; // Oznaczenie konca
  // Tworzenie wskaznika do zadanego elementu:
  return &(storage[index * size]);
}

int Stash::count() {
  return next; // Liczba elementow w Stash
}

void Stash::inflate(int increase) {
  int newQuantity = quantity + increase;
  int newBytes = newQuantity * size;
  int oldBytes = quantity * size;
  unsigned char* b = new unsigned char[newBytes];
  for(int i = 0; i < oldBytes; i++)
    b[i] = storage[i]; // Kopiowanie starego obszaru do nowego
  delete [](storage); // Stary obszar pamieci
  storage = b; // Wskaznik do nowego obszaru
  quantity = newQuantity;
}

Stash::~Stash() {
  if(storage != 0) {
   cout << "zwalnianie pamieci" << endl;
   delete []storage;
  }
}