C++ initialisation POD

Question

J'ai lu sur les objets POD en C++. Je veux avoir une structure POD à écrire dans un fichier. Donc, il devrait avoir seulement des données publiques sans les ctors/dtors etc. Mais pour autant que je sache, il peut avoir une fonction statique. Alors, est-ce que je peux employer "l'idiome nommé par constructeur" ici? J'ai besoin d'initialisation dynamique, mais je ne veux pas reproduire les arguments de vérification à chaque initialisation struct Voici un exemple simple (il est juste simple, exemple, pas un code de travail):

struct A 
{ 
    int day; 
    int mouth; 
    int year; 

    static A MakeA(const int day, const int month, const int year) 
    { 
     // some simple arguments chech 
     if (!(day >= 1 && day <= 31) || !(month >=1 && month <=12) || !(year <= 2010)) 
     throw std::exception(); 

     A result; 
     result.day = day; 
     result.month = month; 
     result.year = year; 
     return result; 
    } 
}; 

J'ai donc quelques-uns une sorte de constructeur et une structure POD que je peux simplement écrire dans un fichier? C'est correct?

Answer 1

Cela devrait aller.

Vous pouvez même avoir un fonctions membres non statiques (tant qu'ils ne sont pas virtuelles)

Vous ne pouvez pas avoir quelque chose qui est appelé automatiquement (comme cteur/dtor). Thingsthat que vous appelez explicitement sont bien.

Answer 2

Si vous écrivez les opérateurs de flux, cela rend la vie beaucoup plus simple.
Ce n'est pas comme si écrire en binaire était beaucoup plus rapide (comme vous avez besoin d'écrire le code à convertir pour différents formats d'endian) et l'espace de nos jours est pratiquement hors de propos.

struct A 
{ 
    int day; 
    int mouth; 
    int year; 

    A(const int day, const int month, const int year) 
    { 
     // some simple arguments chech 
     if (!(day >= 1 && day <= 31) || !(month >=1 && month <=12) || !(year <= 2010)) 
     throw std::exception(); 

     this->day = day; 
     this->month = month; 
     this->year = year; 
    } 
}; 
std::ostream& operator<<(std::ostream& str, A const& data) 
{ 
    return str << data.day << " " << data.month << " " << data.year << " "; 
} 
std::istream& operator>>(std::istream& str,A& data) 
{ 
    return str >> data.day >> data.month >> data.year; 
} 

Avec ceci défini la plethera entière des algorithmes standard devient disponible et facile à utiliser.

int main() 
{ 
    std::vector<A> allDates; 
    // Fill allDates with some dates. 

    // copy dates from a file: 
    std::ifstream history("plop"); 
    std::copy(std::istream_iterator<A>(history), 
       std::istream_iterator<A>(), 
       std::back_inserter(allDates) 
      ); 

    // Now save a set of dates to a file: 
    std::ofstream history("plop2"); 
    std::copy(allDates.begin(), 
       allDates.end(), 
       std::ostream_iterator<A>(history) 
      ); 
} 

Answer 3

Vous avez raison. C'est juste un vieux morceau de données ordinaire. Pas de pointeurs drôles de table virtuelle ou quelque chose comme ça dedans.

Maintenant, je ne suis pas sûr que ce soit une bonne idée d'utiliser simplement fwrite pour écrire les données dans un fichier. Vous pouvez le faire et fread les données de retour à condition que le programme qui fait le fread est écrit avec la même version du compilateur utilisé pour faire le fwrite en premier lieu. Mais si vous changez de compilateurs, de plates-formes, ou même parfois de versions, cela peut changer.

Je suggérerais quelque chose comme Protocol Buffers pour faire le travail de rendre votre structure de données persistante.