ostream implementatuon using printf

Question

Comment implémenter la classe ostream-like à partir de rien en utilisant printf seulement?
Pour me semble que le problème est dans le choix de la chaîne de format, qui est en fait égal à l'identification de type input`s et le traitement de précision

Answer 1

Je suppose que vous voulez dire quelque chose qui surchargent operator<< par « une classe ostream -comme ». Il est facile d'identifier le type de l'argument d'une fonction simplement en ayant des surcharges. Par exemple, vous pouvez avoir:

ostreamlike& ostreamlike::operator<<(int x) 
{ 
    printf("%d", x); 
    return *this; 
} 

ostreamlike& ostreamlike::operator<<(float x) 
{ 
    printf("%f", x); 
    return *this; 
} 

Le format de la sortie est déterminé par la surcharge sélectionnée.

Answer 2

Cela dépend de la proximité du vrai ostream que vous voulez être. En supposant que vous voulez le faire correctement, vous aurez également besoin d'une classe dérivée streambuf. ostream ne fait que le formatage, les E/S réelles sont effectuées par une classe dérivée interne streambuf. Étant donné que streambuf effectue des E/S non formatées, vous devez utiliser fwrite et non printf.

Si votre but est simplement de faire des E/S sur un pointeur FILE* déjà existant, c'est le chemin à parcourir. Vous dérivez une classe de streambuf, dites streambuf_with_FILE puis vous dérivez une autre classe de ostream dites ostream_with_FILE. streambuf_with_FILE remplace les méthodes appropriées pour effectuer les E/S réelles et ostream_with_FILE possède un objet interne streambuf_with_FILE. Il y a en fait très peu de code requis.

Answer 3

penser, il pourrait être quelque chose comme ça

#include <stdio.h> 

class ostreamlike { 
public: 
    ostreamlike(FILE* f_): f(f_) {} 

    ostreamlike& write(int n) { 
    fprintf(f, "%d", n); 
    return *this; 
    } 

    ostreamlike& write(const char* n) { 
    fprintf(f, "%s", n); 
    return *this; 
    } 

private: 
    FILE* f; 
}; 

// operator for types that is supported ostreamlike internally 
template <typename type> 
ostreamlike& operator<<(ostreamlike& stream, const type& data) { 
    return stream.write(data); 
} 

// external implementations to write using ostreamlike 
ostreamlike& operator<<(ostreamlike& stream, bool data) { 
    return stream.write(data ? "true" : "false"); 
} 

int main() { 
    ostreamlike s(stdout); 
    s << "hello " << 1 << " : " << true << "\n"; 
    return 0; 
}