Dynamiczna tablica struktur ze wskaźnikiem

Mam strukturę podana poniżej. Chcę mieć tablicę kilkuelementową takich struktur, którą chcę wypełnić danymi. O ile nie ma problemu z ceną, rocznikiem to z modelem już tak. Nie wiem jak zapisać wartość do "model" bo poniższy sposób generuje błąd. Jak powinien wyglądać poprawny zapis i odczyt "modelu".

struct car {
	double cena;
	int rocznik;
	char * model;
	//char model[30];
};

	//deklaracja tablicy struktur
	car * wsk = new car[5];

        //wypełniam danymi
	for (int i = 0; i < 5; i++)
	{
		cout << "Car#" << i << endl;
		cout << "Podaj cene: ";
		cin >> wsk[i].cena;
		cout << "Podaj rocznik: ";
		cin >> wsk[i].rocznik;

		cout << "Podaj model: ";
		cin >> wsk[i].model;
         }

	for (int i = 0; i < 5; i++)
	{
         cout << wsk[i].model<< "\t" << wsk[i].rocznik << "\t" << wsk[i].cena << endl;
        }

Nie możesz użyć po prostu string?

struct car 
{
    double cena;
    int rocznik;
    std::string model;
};

reszta bez zmian

Zawsze możesz użyć tego http://linux.die.net/man/3/getline owszem tego nie ma w standardzie ale źródła są dostępne i nie są jakieś kosmicznie wielkie.

No właśnie chodzi o to by nie było string - ze stringiem, czy tablicą w miejsce *char nie mam problemu. Problem jest czysto "akademicki" ;)

Bo string alokuje pamięć za Ciebie, a jeśli chcesz mieć pole struktury będące wskażnikiem musisz sobie tą pamięć zaalokować samodzielnie.
Dodaj:

        cin >> wsk[i].model;        cout << "Podaj model: ";
        wsk[i].model = new char[30]; // inicjalizacja wskaznika jakims miejscem, bo do tej pory to byl tylko pusty adres
        cin >> wsk[i].model;

#include <cstdio>

struct car {
	static constexpr size_t str_buff_size = 64;
	char model[str_buff_size];
};


int main() {
	constexpr size_t cars_count = 5;
	car cars[cars_count];
	for(size_t i = 0; i < cars_count; ++i) {
		fgets(cars[i].model, car::str_buff_size, stdin);
		printf("%u: %s", i, cars[i].model);
	}
	return 0;
}

http://ideone.com/nxetZg

//EDIT: nie no, @bufnal, jeśli bawimy się w takie alokowanie pamięci na ostatnią chwilę, to bawmy się na całego :D

#include <iostream>
#include <functional>
#include <array>
#include <cassert>
#include <cstdlib>
using namespace std;

template<typename T>
class lazy {
	using init_func_t = function<T()>;
	mutable T value;
	mutable init_func_t init;
public:
	lazy(init_func_t func): init(func){
		assert(init);
	}
	
	lazy(const T &v): value(v){}
	
	lazy(const lazy &other){
		lazy(other.init.target());
	}
	
	
	operator T() const{
		if(init){
			value = init();
			init = init_func_t();
		}
		return value;
	}
	
	lazy<T> &operator=(const lazy<T> &other){
		if(other.init){
			init = init_func_t(other.init.target());
		}
		else{
			init = init_func_t();
			value = other;
		}
		return *this;
	}
};

struct car{
	static constexpr size_t str_buff_size = 64;
	lazy<char *> model { []{return new char[str_buff_size];} };
};

int main(){
	array<car, 5> cars;
	for(auto &car: cars){
		fgets(car.model, car::str_buff_size, stdin);
		printf(car.model);
	}
	return 0;
}

http://ideone.com/QUOxuJ

(oczywiście wypadałoby użyć unique_ptr żeby sprzątał po nas, ale zważywszy na godzinę, nawet nie próbowałem testować tego lazy<T>. Skompilowało się, znaczy się git!)