spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

template<typename StreamType>
StreamType& operator>>(StreamType &stream, STileConfig &object)
{
    stream >> object.bBackroudGrass;
    stream >> object.bWay;
    return stream;
};

C-/C++-Quelltext

struct STileConfig
{
    STileConfig() : bBackroudGrass(true), bWay(false) {}; //Standardkonstruktor

    bool bBackroudGrass;
    bool bWay;
};

//Schreibt in beliebige stream typen, die write mit der gegebenen Signatur unterstützen.
template<typename StreamType>
StreamType& operator<<(StreamType &stream, STileConfig &config)
{
    stream.write((char*)(&config.bBackroudGrass), sizeof(bool));
    stream.write((char*)(&config.bWay), sizeof(bool));
    return stream;
};

//Liest aus beliebigen streams, die die gegebene Signatur unterstützen.
template<typename StreamType>
StreamType& operator>>(StreamType &stream, STileConfig &config)
{
    char buffer[2];
    stream.read(&buffer[0], 2);
    config.bBackroudGrass = buffer[0];
    config.bWay = buffer[1];
    return stream;
};

//Helferfunktion, um main() für das Beispiel ein wenig frei zu halten ;)
void fill_random_config(vector<STileConfig> &fill)
{
    for(int i = 0; i < 10; ++i)
    {
        STileConfig temp;
        temp.bBackroudGrass = rand() % 2 == 0? true : false;
        temp.bWay = rand() % 2 == 0? true : false;
        fill.push_back(temp);
        cout << "Added STileConfig:" << temp.bBackroudGrass << "/" << temp.bWay << endl;
    }
};

/* Main entry point of the application */
int main(int argc, char** argv)
{
    vector<STileConfig> m_vConfig;
    //Fix mit irgendwas auffüllen ;)
    fill_random_config(m_vConfig);


    ofstream out("Test.txt", ios::binary);
        //Das ruft jetzt das obige template auf, also operator<<(out, *config), es wird also binär geschrieben.
    for(vector<STileConfig>::iterator config = m_vConfig.begin(); config != m_vConfig.end(); ++config)
        out << *config;
        
        //Flushen nicht vergessen. Ohne gings nicht :p
    out.flush();
    out.close();

    m_vConfig.clear();

    ifstream input("Test.txt", ios::binary);
        //Benutzt intern das obige template, also operator>>(input, temporary_STileConfig), wird also binär gelesen.
    copy(istream_iterator<STileConfig>(input), istream_iterator<STileConfig>(), back_inserter(m_vConfig));
        
        //Nur mal testweise noch ausgeben. Hat aber funktioniert :) Hoffe es funktioniert bei dir auch noch.
    for(vector<STileConfig>::iterator config = m_vConfig.begin(); config != m_vConfig.end(); ++config)
        cout << "Found config: " << config->bBackroudGrass << "/" << config->bWay << endl;

        //system("pause") funktioniert bei mir mitm gcc nicht, falls du MSVC benutzt kannst du das wider reinnehmen. 
    //system("pause");
};

C-/C++-Quelltext

#include <iostream> // std::istream, std::ostream
#include <iterator> // std::istream_iterator, std::ostream_iterator, std::back_inserter
#include <vector> // std::vector
#include <cstdlib> // std::srand, std::rand
#include <algorithm> // std::copy
#include <ctime> // std::time


struct TileConfig
{
    TileConfig(const bool backgroundGras = true, const bool way = false) 
        : BackroudGras(backgroundGras), Way(way)
    {}

    bool BackroudGras;
    bool Way;

    friend std::ostream& operator<<(std::ostream& out, TileConfig const& data) 
    { return (out << data.BackgroundGras << data.Way); }
    friend std::istream& operator>>(std::istream& in, TileConfig& data) 
    { return (in >> data.BackgroundGras >> data.Way); }
};

void random_config(std::vector<TileConfig>& data, const unsigned int max = 10)
{
    for (unsigned int i(0); i < max; ++i)
        data.push_back(TileConfig(std::rand() % 2 == 0, std::rand() % 2 == 0));
}

int main() 
{
    std::srand(static_cast<unsigned int>(std::time(NULL)));
    std::vector<TileConfig> tiles;
    random_config(tiles, 100);

    std::cout << "Random Configs: " << std::endl;
    std::copy(tiles.begin(), tiles.end(), std::ostream_iterator<TileConfig>(std::cout, "\n\n"));

    { // save to file
        std::ofstream file_stream("config.dat");
        std::copy(tiles.begin(), tiles.end(), std::ostream_iterator<TileConfig>(std::cout, "\n"));
    }
    tiles.clear();
    { // read from file
        std::ifstream file_stream("config.dat");
        std::copy(std::istream_iterator<TileConfig>(file_stream), std::istream_iterator<TileConfig>(), std::back_inserter(tiles));
    }
    std::cout << "Read configs: " << std::endl;
    std::copy(tiles.begin(), tiles.end(), std::ostream_iterator<TileConfig>(std::cout, "\n\n"));     
}