C++ - inicjowanie stałej przy wczytaniu z pliku (serialiacja)

Witam,
Zastanawiam się nad następującym problemem. Mam sobie pewną stałą składową, którą wrzucam do pliku (ustawiana na liście inicjalizacyjnej konstruktora / w konstruktorze - jest to jedno z pól w klasie). Tylko wtedy mogę ustawić wartość pola, które posiada atrybut const. Następnie zrzucam to do pliku. Tu nie ma żadnego problemu, po prostu piszę do strumienia.

Problem pojawia się, gdy chcę wczytać to pole z pliku. Czy można to zrobić inaczej jak tworząc odpowiedni konstruktor? Zależy mi na utworzeniu funkcji wczytaj, która jako jedyna (podobnie jak konstruktor) będzie mogła ustawić pole const.

Inny pomysł to:
a) w metodzie wczytującej wywołać destruktor
b) następnie wywołać konstruktor, który zastąpi obiekt innym (ale to nie działa)

Pozdrawiam,

Niech będzie to po prostu metoda statyczna, która stworzy ci nowy obiekt.

Brzmi prosto, dzięki!

Jednak odpowiedni konstruktor brzmi bardziej sensownie.

Mam taką klasę:

#ifndef MOJAKLASA_H
#define MOJAKLASA_H

#include <string>
#include <iostream>
#include <fstream>

class MojaKlasa
{
protected:
    std::string name;
    const std::string pesel;
public:
    MojaKlasa(std::string name, std::string pesel);
    MojaKlasa(std::ifstream&);
    std::string get_name();
    void set_name(std::string);
    std::string get_pesel();
    void zapisz(std::ofstream&) const;
    static MojaKlasa wczytaj(std::ifstream&, MojaKlasa&);
};

#endif // MOJAKLASA_H

#include "mojaklasa.h"

using namespace std;

MojaKlasa::MojaKlasa(string imie, string pesel) : name(imie), pesel(pesel) {
    pesel = "dupa";
}

MojaKlasa::MojaKlasa(ifstream &in) : pesel("")
{
//    in >> this->pesel;
    in >> this->name;
}

string MojaKlasa::get_name()
{
    return name;
}

void MojaKlasa::set_name(std::string name)
{
    this->name = name;
}

string MojaKlasa::get_pesel()
{
    return pesel;
}

void MojaKlasa::zapisz(std::ofstream& plik) const
{
    plik << pesel << endl;
    plik << name << endl;
    plik.close();
}
static MojaKlasa wczytaj(std::ifstream& plik, MojaKlasa& obj)
{
    string pesel, name;
    plik >> pesel;
    plik >> name;
    plik.close();

    static MojaKlasa nowy(name, pesel);
}

Zastanawia mnie:

1. Dlaczego pierwszy konstruktor może zmodyfikować zmienną, a drugi nie (narzeka na brak konwersji między const::std string)?
2. Jak to obejść?

Ad1. Nie możesz zmienić stałej zawartej w strukturze.
Ad2. Napisać konstruktor kopiujący,

• Nie zamykaj pliku przy wczytywaniu i zapisywaniu, umożliwi to zapisanie i wczytanie kilku obiektów podrząd.
• Nie musisz przekazywać obiektu:
  static MojaKlasa wczytaj(std::ifstream& plik)
  {
  string pesel, name;
  plik >> pesel >> ws >> name;
  return MojaKlasa(name, pesel);
  }
• Realizacja konstruktora ze strumieniem:
  static string MojaKlasa::rs(istream &in) { string s; in>>s>>ws; return s; }
  MojaKlasa::MojaKlasa(ifstream &in) : pesel(rs(in)),name(rs(in))
  {
  }
  i nie potrzebujesz metody wczytaj.