Herdando std :: istream ou equivalente
Pergunta
Eu preciso unir duas bibliotecas sobre um córrego.
QDataStream which is a stream from Qt
e alguma função de outro bibliotecas que se parece com isso
void read_something(istream& i);
Eu não tenho nenhum controle sobre como o QDataStream é criado e eu não estou autorizado a alterar a interface de read_somthing função.
A primeira coisa que eu posso pensar é escrever uma classe que herda iStream e envolve QDataStream. Já ninguém fez isso antes?
Se o que eu pensei que não era a maneira correta, eu me pergunto qual é a melhor maneira de conseguir isso.
Solução
O que você deve fazer é escrever uma streambuf que utiliza a QDataStream readBytes e writeBytes para implementar as suas funções. Em seguida, registrar o streambuf em um istream com rdbuf (você também pode escrever um descendente istream que faz isso quando inicializado).
Aumento contém uma biblioteca com o objetivo de facilitar a escrita de streambuf. Poderia ser mais simples para usá-lo do que entender a interface streambuf (pessoalmente eu nunca usei, mas eu escrevi múltipla streambuf, eu vou ver se eu tenho um exemplo que eu posso postar).
Edit: aqui está algo (comentado em francês - ele vem do FAQ francês de fr.comp.lang.c ++ -, eu não tenho tempo para tradução e acho que é melhor deixá-los do que para removê-los) que envolve * chamada arquivo em um streambuf. Isso também é um show case de um uso de herança private: garantir que o que poderia ser um membro é inicializado antes de uma classe base. No caso de iostream, a classe de base pode assim receber um ponteiro nulo e, em seguida, o membro de init () usada para definir o streambuf.
#include <stdio.h>
#include <assert.h>
#include <iostream>
#include <streambuf>
// streambuf minimal encapsulant un FILE*
// - utilise les tampons de FILE donc n'a pas de tampon interne en
// sortie et a un tampon interne de taille 1 en entree car l'interface
// de streambuf ne permet pas de faire moins;
// - ne permet pas la mise en place d'un tampon
// - une version plus complete devrait permettre d'acceder aux
// informations d'erreur plus precises de FILE* et interfacer aussi
// les autres possibilites de FILE* (entre autres synchroniser les
// sungetc/sputbackc avec la possibilite correspondante de FILE*)
class FILEbuf: public std::streambuf
{
public:
explicit FILEbuf(FILE* cstream);
// cstream doit etre non NULL.
protected:
std::streambuf* setbuf(char_type* s, std::streamsize n);
int_type overflow(int_type c);
int sync();
int_type underflow();
private:
FILE* cstream_;
char inputBuffer_[1];
};
FILEbuf::FILEbuf(FILE* cstream)
: cstream_(cstream)
{
// le constructeur de streambuf equivaut a
// setp(NULL, NULL);
// setg(NULL, NULL, NULL);
assert(cstream != NULL);
}
std::streambuf* FILEbuf::setbuf(char_type* s, std::streamsize n)
{
// ne fait rien, ce qui est autorise. Une version plus complete
// devrait vraissemblablement utiliser setvbuf
return NULL;
}
FILEbuf::int_type FILEbuf::overflow(int_type c)
{
if (traits_type::eq_int_type(c, traits_type::eof())) {
// la norme ne le demande pas exactement, mais si on nous passe eof
// la coutume est de faire la meme chose que sync()
return (sync() == 0
? traits_type::not_eof(c)
: traits_type::eof());
} else {
return ((fputc(c, cstream_) != EOF)
? traits_type::not_eof(c)
: traits_type::eof());
}
}
int FILEbuf::sync()
{
return (fflush(cstream_) == 0
? 0
: -1);
}
FILEbuf::int_type FILEbuf::underflow()
{
// Assurance contre des implementations pas strictement conformes a la
// norme qui guaranti que le test est vrai. Cette guarantie n'existait
// pas dans les IOStream classiques.
if (gptr() == NULL || gptr() >= egptr()) {
int gotted = fgetc(cstream_);
if (gotted == EOF) {
return traits_type::eof();
} else {
*inputBuffer_ = gotted;
setg(inputBuffer_, inputBuffer_, inputBuffer_+1);
return traits_type::to_int_type(*inputBuffer_);
}
} else {
return traits_type::to_int_type(*inputBuffer_);
}
}
// ostream minimal facilitant l'utilisation d'un FILEbuf
// herite de maniere privee de FILEbuf, ce qui permet de s'assurer
// qu'il est bien initialise avant std::ostream
class oFILEstream: private FILEbuf, public std::ostream
{
public:
explicit oFILEstream(FILE* cstream);
};
oFILEstream::oFILEstream(FILE* cstream)
: FILEbuf(cstream), std::ostream(this)
{
}
// istream minimal facilitant l'utilisation d'un FILEbuf
// herite de maniere privee de FILEbuf, ce qui permet de s'assurer
// qu'il est bien initialise avant std::istream
class iFILEstream: private FILEbuf, public std::istream
{
public:
explicit iFILEstream(FILE* cstream);
};
iFILEstream::iFILEstream(FILE* cstream)
: FILEbuf(cstream), std::istream(this)
{
}
// petit programme de test
#include <assert.h>
int main(int argc, char* argv[])
{
FILE* ocstream = fopen("result", "w");
assert (ocstream != NULL);
oFILEstream ocppstream(ocstream);
ocppstream << "Du texte";
fprintf(ocstream, " melange");
fclose(ocstream);
FILE* icstream = fopen("result", "r");
assert (icstream != NULL);
iFILEstream icppstream(icstream);
std::string word1;
std::string word2;
icppstream >> word1;
icppstream >> word2;
char buf[1024];
fgets(buf, 1024, icstream);
std::cout << "Got :" << word1 << ':' << word2 << ':' << buf << '\n';
}
Outras dicas
A solução impulso stream:
namespace boost {
namespace iostreams {
class DataStreamSource
{
public:
typedef char char_type;
typedef source_tag category;
DataStreamSource( QDataStream *const source ) : m_source(source){
}
std::streamsize read(char* buffer, std::streamsize n) {
return m_source ? m_source->readRawData(buffer, n) : -1;
}
private:
QDataStream *const m_source;
};
}
}
// using DataStreamSource
namespace io = boost::iostreams;
QFile fl("temp.bin");
fl.open(QIODevice::ReadOnly);
QDataStream s(&fl);
io::stream< io::DataStreamSource > dataStream( &s );
read_something(dataStream);