espaces ne sont pas l'impression lorsque lit le fichier d'entrée

Question

Je suis en train de lire chaque « char » du fichier d'entrée et écrire dans le fichier de sortie jusqu'à ce que trouve le « ? » comme la fin du fichier. Chaque caractère est écrit dans le fichier de sortie sauf les espaces entre les mots. Je ne sais pas ce qui ne va pas dans ce code ??

#include <iostream> 
#include <fstream> 
using namespace std; 
int main() 
{ 
    ifstream infile("in.txt"); 
    ofstream outfile("out.txt"); 
    char ch; 
    infile >> ch; 
    while(ch != '?') 
    { 
    outfile<<ch; 
    infile >> ch; 
    } 
} 

Answer 1

Essayez d'utiliser noskipws sur ... Lire

infile >> noskipws >> ch; 

Le noskipws indique le flux d'entrée pour ne pas sauter des espaces où il fait par défaut.

Answer 2

L'opérateur istream >> ignore les espaces. Essayez ceci:

std::string s; 
std::getline(infile,s,'?'); 
outfile << s; 

Answer 3

Le >> opérateur pour les flux d'entrée est généralement associée à l'interprétation. Par exemple, en lisant string s il saute des espaces. Cela peut être le cas lors de la lecture char s. Vous devez utiliser la méthode read, par exemple:

infile.read(&ch, 1) 

Voir http://www.cplusplus.com/reference/iostream/ifstream/ pour référence

modifier J'ai oublié la méthode get. Cela vous obtiendra un seul personnage, porté comme int. La méthode read est plus adaptée pour lire un morceau de données en un appel.

Answer 4

Blanc a déjà @ Andrew indiqué comment résoudre le problème que vous avez vu. Je vais jeter dans mon idée (en général pour moi, probablement trop d'ingénierie) idée de la façon de faire le reste du travail:

#pragma once 
#if !defined(SENTINEL_ITERATOR_H_) 
#define SENTINEL_ITERATOR_H_ 
#include <istream> 
#include <iterator> 

template <class T, 
      class charT=char, 
      class traits=std::char_traits<charT>, 
      class distance = ptrdiff_t> 

class sentinel_iterator : 
    public std::iterator<std::input_iterator_tag,distance,void,void,void> 
{ 
    std::basic_istream<charT,traits> *is; 
    T value; 
public: 
    typedef charT char_type; 
    typedef traits traits_type; 
    typedef std::basic_istream<charT,traits> istream_type; 

    sentinel_iterator(istream_type& s) 
     : is(&s) 
    { s >> value; } 

    sentinel_iterator(T const &s) : is(0), value(s) { } 

    const T &operator*() const { return value; } 
    const T *operator->() const { return &value; } 

    sentinel_iterator &operator++() { 
     (*is)>>value; 
     return *this; 
    } 

    sentinel_iterator &operator++(int) { 
     sentinel_iterator tmp = *this; 
     (*is)>>value; 
     return (tmp); 
    } 

    bool operator==(sentinel_iterator<T,charT,traits,distance> const &x) { 
     return value == x.value; 
    } 

    bool operator!=(sentinel_iterator<T,charT,traits,distance> const &x) { 
     return !(value == x.value); 
    } 
}; 

#endif 

Ensuite, le code devient quelque chose comme ceci:

#include <algorithm> 
#include <fstream> 
#include "sentinel_iterator.h" 

int main() { 
    ifstream infile("in.txt"); 
    ofstream outfile("out.txt"); 

    infile >> noskipws; 

    std::copy(sentinel_iterator<char>(infile), 
       sentinel_iterator<char>('?'), 
       std::ostream_iterator<char>(outfile)); 
    return 0; 
}