C++ - Kopie ein stream-Objekt

Ich habe experimentiert mit C++, und ich habe auf ein problem stoßen, dass ich nicht weiß, wie zu lösen.

Im Grunde, habe ich entdeckt, dass Sie nicht kopieren können-streams (siehe Warum das kopieren von stringstream ist nicht erlaubt?), und das gilt auch für Objekte, die 'wrap' Sie. Zum Beispiel:

  • Ich erstelle eine Klasse ein Datenelement vom Typ stringstream.
  • Erzeuge ich ein Objekt dieser Klasse.
  • Ich versuchen, um das Objekt zu kopieren, z.B. "TestObj t1; TestObj t2; t1 = t2;"

Diese den Fehler verursacht C2249:

'std::basic_ios<_Elem,_Traits>::operator =' : Nein, Barrierefreier Weg, um private member deklariert virtual base 'std::basic_ios<_Elem,_Traits>'

Also meine Frage ist: wie kann ich (vorzugsweise leicht) Objekte kopieren, die Mitglieder-Daten des Typs *stream?

Vollständige Beispiel-code:

#include <iostream>
#include <string>
#include <sstream>

class TestStream
{
public:
    std::stringstream str;
};

int main()
{
    TestStream test;
    TestStream test2;
    test = test2;

    system("pause");
    return 0;
}

Vielen Dank im Voraus.

UPDATE

Habe ich es geschafft dieses problem zu lösen, Dank der Antworten unten. Was ich getan habe ist, erklären die stream-Objekte einmal und dann verweisen Sie einfach auf Sie mit Zeigern in der wrapper-Objekte (z.B. TestStream). Das gleiche gilt für alle anderen Objekte, die privaten copy-Konstruktoren.

  • Da Sie scheinen Ihre Hausaufgaben gemacht haben, wird die verknüpfte Frage. Warum benötigen Sie dieses Verhalten? Lesen/schreiben?
InformationsquelleAutor Matt Larsen | 2011-10-26
  1. 5

    Der Grund, Sie sind nicht erlaubt zu kopieren, ein stream ist, dass es macht keinen Sinn zu kopieren stream. Wenn Sie erklären, was es ist, dass Sie versuchen zu tun, es ist sicherlich ein Weg, es zu tun. Wenn Sie wollen, ein Stück von Daten, die Sie kopieren können, verwenden Sie eine Zeichenfolge. Aber ein stream ist eher eine Verbindung als ein string.

    • Was ist, wenn ich Sie kopieren möchten, mit die Verbindung? I. e., Ich bin einer Datei zu Lesen, und ich Erreiche eine Linie, ich weiß, ich werde zu haben, um Sie später zu Lesen (oder Gruppe von Zeilen zu groß, um zu speichern). Es wäre zweckmäßig, kopieren Sie den stream, so dass die Kopie wird an dieser Stelle in den Bach, und dann in der Lage sein, wieder zu kommen, um es später.
    • Das macht keinen Sinn im Allgemeinen. Das könnte Sinn machen, für einige Arten von streams, sondern als eine Allgemeine Funktion der stream, ist es nicht sinnvoll.
    • Ich denke, dass ich gefunden, was ich brauche (ja, es war für istreams only) - speichern der aktuellen stream-position mit tellg und mit seekg später.
    • Achten Sie darauf, dass seekg() und seekp() bewegen sich manchmal gemeinsam und manchmal nicht, je nachdem, welche Art von Strom Sie nutzen.
    InformationsquelleAutor David Schwartz
  2. 2

    Dieser Artikel bietet Möglichkeiten, es zu tun. Beachten Sie jedoch die interessante Zusammenfassung:

    In der Zusammenfassung, erstellen eine Kopie einer Strom ist nicht trivial und sollte nur
    getan werden, wenn Sie wirklich brauchen, eine Kopie von einem stream-Objekt    . In vielen Fällen,
    es ist sinnvoller zu verwenden, die Referenzen oder Zeiger, um stream-Objekte
    statt, oder teilen Sie einen stream-Puffer zwischen zwei Bächen.

    InformationsquelleAutor JRL
  3. 1

    Sicherlich hast du zum schreiben der copy-Konstruktor und copy-Zuweisungsoperator selbst.

    Als Nächstes müssen Sie entscheiden, welche Semantik Sie möchte die Kopie haben. Also:

    TestStream test;
TestStream test2;
test2 << "foo"
test = test2;
test << "bar";

test2.str.str(); //should this be "foo" or "foobar" ?

    Wenn Sie möchten, eine flache Kopie, ( "foobar" ), dann Sie teilen müssen, die stringstream-Objekt zwischen mehreren Instanzen von TestStream wahrscheinlich am besten verwenden Sie ein shared_ptr für, die.

    Wenn Sie möchten, eine Tiefe Kopie ("foo"), dann könnte man kopieren, wie diese:

    TestStream(const TestStream &rhs) : str(rhs.str.str()) {}

    Oder verwenden Sie eine der Varianten in der Frage, die Sie verknüpfen.

    Deckt ein stringstream, um die Sie sind in der Mitte der schreiben, wenn Sie die Kopie. Wenn Sie in der Mitte des Lesen aus, oder wenn Sie schreiben, aber Sie könnten nicht schreiben, um am Ende wegen der Verwendung von seekp, dann müssen Sie erfassen die aktuelle lese - /schreib-Position, sowie die Daten in den stringstream, die Sie tun, mit tellg/tellp.

    Vielleicht wollen Sie auch kopieren über das stream-format, Status, und so weiter, das ist, was copyfmt tut, und sogar die Fehler flags (rdstate -- copyfmt lässt Sie allein).

    InformationsquelleAutor Steve Jessop
  4. 0

    Gibt es zwei Dinge, die Sie tun können, sowohl vorsichtig darüber, wer das Objekt besitzt:

    1. Speichern eine Referenz auf einen stream, und stellen Sie sicher, dass das Objekt nicht mehr gültig sind, solange diese Klassen von Ihnen sind rund.

    2. kopieren Sie den Zeiger herum, und werden sicher erst dann zu löschen, wenn die Letzte der Klassen erfolgt mit dem stream-Objekt hinwies.

    Beide sind gleichwertig, wobei ich persönlich lieber die reference-Ansatz.

    • Wenn Sie sich für das 2. und muss einen compiler kann C++11 könnte man smart-Pointer. Wenn Sie nicht mit einem solchen compiler können Sie mit der boost-library oder schreiben Sie eine smart-pointer-Klasse selbst.
    • vereinbart. Dies ist ein Fall, wo boost::shared_ptr geeignet ist (und auf jeden Fall vorzuziehen, um eine der alternativen).
    InformationsquelleAutor rubenvb
  5. 0

    Testen Sie die Leistung verschiedener schreib-Operationen in c++, hier ist ein code, der kompiliert auf Ihrem Rechner und tests schreiben-Operationen mit und ohne Pufferung mit mehreren Methoden:

    Link

    #include <stdio.h>
#include <cstring>
#include <iostream>
#include <fstream>
#include <chrono>

#define TOCOUT(output) \
    if(!outputToCout) { \
        buf = output##_t.rdbuf(); \
    } else { \
        buf = std::cout.rdbuf(); \
    } \
    std::ostream output(buf);

void fstreamBufferTest(){

    const bool outputToCout = true;

    const unsigned int multiplyStep = 1<<2;
    const unsigned int startLength = 1<<2;
    const unsigned int stopLength = 1<<24;

    const unsigned int writeNTimes = 1; //Averaging over some many times!
    const unsigned int fileLength = 1<< 30; //104857600=100mb,  314572800=300mb , 1<< 30 =1GB
    std::string add = "1000.txt";
    unsigned int loops, restBytes;


    std::streambuf * buf;

    std::ofstream output1_t("FStreamTest-FstreamBuffering-OwnBufferSet-"+add);
    TOCOUT(output1);
    output1 << "#Buffer Length \tTimeToWrite \tWriteSpeed [mb/s]" << std::endl;

    std::ofstream output2_t("FStreamTest-ManualBuffering-StdStreamBuffer-"+add);
    TOCOUT(output2);
    output2 << "#Buffer Length \tTimeToWrite \tWriteSpeed [mb/s]" << std::endl;

    std::ofstream output3_t("FStreamTest-ManualBuffering-NoInternalStreamBuffer-"+add);
    TOCOUT(output3);
    output3 << "#Buffer Length \tTimeToWrite \tWriteSpeed [mb/s]" << std::endl;

    std::ofstream output4_t("FStreamTest-NoManualBuffering-NoInternalStreamBuffer-"+add);
    TOCOUT(output4);
    output4 << "#Buffer Length \tTimeToWrite\tWriteSpeed [mb/s]" << std::endl;

    std::ofstream output5_t("FStreamTest-NoManualBuffering-StdStreamBuffer-"+add);
    TOCOUT(output5);
    output5 << "#Buffer Length \tTimeToWrite \tWriteSpeed [mb/s]" << std::endl;

    //To Cout


    typedef std::chrono::duration<double> fsec;
    typedef std::chrono::high_resolution_clock Clock;



    //Test Data for the Buffer
    bool removeFile = true;
    char value = 1;
    char *testData = new char[fileLength]; //Just Garbage 1GB!!
    std::memset(testData,value,fileLength);

    //Preallocate file;
    if(!removeFile){
        std::fstream stream;
        stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);
        for(int i = 0; i < writeNTimes; i++){
                stream.write(testData, fileLength );
        }
        stream.close();
    }else{
        if( remove( "test.dat" ) == 0){
            std::cout << "File deleted at start!" << std::endl;
        }
    }

    for(unsigned int bufL = startLength; bufL <= stopLength; bufL = bufL * multiplyStep){

        //First Test with Fstream Buffering!
        {
            std::cout << "Doing test: FStream Buffering: " << bufL <<std::endl;
            char * buffer = new char[bufL];
            //open Stream
            std::fstream stream;
            stream.rdbuf()->pubsetbuf(buffer, bufL);
            stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);

            //Write whole 1gb file! we have fstream buffering the stuff
            auto t1 = Clock::now();
            for(int i = 0; i < writeNTimes; i++){
                stream.write(testData, fileLength );
            }
            stream.close();
            auto t2 = Clock::now();

            //Calculate timing
            fsec time = (t2 - t1) / writeNTimes;
            output1 << bufL << "\t" << time.count() <<"\t" << (fileLength/time.count()) / (1024*1024) << std::endl;

            delete buffer;
            if(removeFile){
                if( remove( "test.dat" ) != 0){
                    std::cerr << "File not deleted" << std::endl;
                };
            }
        }

        //Second Test with Manual Buffering!
        {
            std::cout << "Doing test: Manual Buffering: " << bufL <<std::endl;
            //Calculate the loops to write fileLength
            loops = fileLength / bufL;
            restBytes =  fileLength % bufL;

            //open Stream
            std::fstream stream;
            stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);
            //TODO stream buf -> 0

            //Write 1GB File in loops of bufL
            auto t1 = Clock::now();
            for(int i = 0; i < writeNTimes;  i++){
                for(int i = 0; i < loops; i++){
                   stream.write(testData, bufL );
                }
                stream.write(testData, restBytes );
            }
            stream.close();
            auto t2 = Clock::now();

            //Calculate timing
            fsec time = (t2 - t1) / writeNTimes;
            output2 << bufL << "\t" << time.count() <<"\t" << (fileLength/time.count()) / (1024*1024) << std::endl;
            if(removeFile){
                if( remove( "test.dat" ) != 0){
                    std::cerr << "File not deleted" << std::endl;
                };
            }
        }

        //Second Test with Manual Buffering!
        {
            std::cout << "Doing test: Manual Buffering (no internal stream buffer): " << bufL <<std::endl;
            //Calculate the loops to write fileLength
            loops = fileLength / bufL;
            restBytes =  fileLength % bufL;

            //open Stream
            std::fstream stream;
            stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);
            stream.rdbuf()->pubsetbuf(0, 0);

            //Write 1GB File in loops of bufL
            auto t1 = Clock::now();
            for(int i = 0; i < writeNTimes;  i++){
                for(int i = 0; i < loops; i++){
                   stream.write(testData, bufL );
                }
                stream.write(testData, restBytes );
            }
            stream.close();
            auto t2 = Clock::now();

            //Calculate timing
            fsec time = (t2 - t1) / writeNTimes;
            output3 << bufL << "\t" << time.count() <<"\t" << (fileLength/time.count()) / (1024*1024) << std::endl;
            if(removeFile){
                if( remove( "test.dat" ) != 0){
                    std::cerr << "File not deleted" << std::endl;
                };
            }
        }


        {
            std::cout << "Doing test: No manual Buffering (no internal stream buffer): " << bufL <<std::endl;
            //Calculate the loops to write fileLength
            loops = fileLength / bufL;
            restBytes =  fileLength % bufL;

            //open Stream
            std::fstream stream;
            stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);
            stream.rdbuf()->pubsetbuf(0, 0);

            //Write 1GB File in loops of bufL
            auto t1 = Clock::now();
            for(int i = 0; i < writeNTimes;  i++){
                stream.write(testData, fileLength );
            }
            stream.close();
            auto t2 = Clock::now();

            //Calculate timing
            fsec time = (t2 - t1) / writeNTimes;
            output4 << bufL << "\t" << time.count() <<"\t" << (fileLength/time.count()) / (1024*1024) << std::endl;
            if(removeFile){
                if( remove( "test.dat" ) != 0){
                    std::cerr << "File not deleted" << std::endl;
                };
            }
        }

        {
            std::cout << "Doing test: No manual Buffering (std stream buffer): " << bufL <<std::endl;
            //Calculate the loops to write fileLength
            loops = fileLength / bufL;
            restBytes =  fileLength % bufL;

            //open Stream
            std::fstream stream;
            stream.open("test.dat", std::ios::binary | std::ios::trunc | std::ios::out);

            //Write 1GB File in loops of bufL
            auto t1 = Clock::now();
            for(int i = 0; i < writeNTimes;  i++){
                stream.write(testData, fileLength );
            }
            stream.close();
            auto t2 = Clock::now();

            //Calculate timing
            fsec time = (t2 - t1)/ writeNTimes;
            output5 << bufL << "\t" << time.count() <<"\t" << (fileLength/time.count()) / (1024*1024) << std::endl;
            if(removeFile){
                if( remove( "test.dat" ) != 0){
                    std::cerr << "File not deleted" << std::endl;
                };
            }
        }



    }



}

int main() {
fstreamBufferTest();
}
    InformationsquelleAutor Gabriel
Schreibe einen Kommentar