basic_istream-klass

Beskriver ett objekt som styr extrahering av element och kodade objekt från en strömbuffert med element av typen Char_T, även kallat char_type, vars karaktärsdrag bestäms av klassen Tr, även kallat traits_type.

Syntax

template <class Char_T, class Tr = char_traits<Char_T>>
class basic_istream : virtual public basic_ios<Char_T, Tr>

Anmärkningar

De flesta medlemsfunktioner som överbelastas operator>> är formaterade indatafunktioner. De följer mönstret:

iostate state = goodbit;
const sentry ok(*this);

if (ok)
{
    try
    {
        /*extract elements and convert
            accumulate flags in state.
            store a successful conversion*/
    }
    catch (...)
    {
        try
        {
            setstate(badbit);

        }
        catch (...)
        {
        }
        if ((exceptions()& badbit) != 0)
            throw;
    }
}
setstate(state);

return (*this);

Många andra medlemsfunktioner är oformaterade indatafunktioner. De följer mönstret:

iostate state = goodbit;
count = 0;    // the value returned by gcount
const sentry ok(*this, true);

if (ok)
{
    try
    {
        /* extract elements and deliver
            count extracted elements in count
            accumulate flags in state */
    }
    catch (...)
    {
        try
        {
            setstate(badbit);

        }
        catch (...)
        {
        }
        if ((exceptions()& badbit) != 0)
            throw;
    }
}
setstate(state);

Båda grupperna av funktioner anropar setstate(eofbit) om de stöter på slutet av filen när element extraheras. Mer information finns i setstate.

Ett objekt i klassarkiv basic_istream<Char_T, Tr> :

• Ett virtuellt offentligt basobjekt för klassen basic_ios<Char_T, Tr>. Mer information finns i basic_ios.

• Ett extraheringsantal för den senaste oformaterade indataåtgärden (anropas count i föregående kod).

Exempel

Se exemplet för Klass för basic_ifstream att lära dig mer om indataströmmar.

Konstruktörer

Medlemsfunktioner

Operatörer

Kravspecifikation

rubrik:<istream>

Namespace:std

basic_istream::basic_istream

Konstruerar ett objekt av typen basic_istream.

explicit basic_istream(
    basic_streambuf<Char_T, Tr>* strbuf,
    bool _Isstd = false);

basic_istream(basic_istream&& right);

Parameterar

strbuf
Ett objekt av typen basic_streambuf.

_Isstd
trueom det är en standardström; annars . false

right
Ett basic_istream objekt som ska kopieras.

Anmärkningar

Den första konstruktorn initierar basklassen genom att anropa init(strbuf). Den lagrar också noll i extraheringsantalet. Mer information finns i init. Mer information om det här extraheringsantalet finns i avsnittet Anmärkningar i klassöversiktenbasic_istream.

Den andra konstruktorn initierar basklassen genom att anropa move(right). Den lagrar right.gcount() även i extraheringsantalet och lagrar noll i extraheringsantalet för right.

Exempel

Mer information om indataströmmar finns i exemplet basic_ifstream::basic_ifstream .

basic_istream::gcount

Returnerar antalet tecken som lästes under den senaste oformaterade inmatningen.

streamsize gcount() const;

Returvärde

Extraheringsantalet.

Anmärkningar

Använd basic_istream::get för att läsa oformaterade tecken.

Exempel

// basic_istream_gcount.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   cout << "Type the letter 'a': ";

   ws( cin );
   char c[10];

   cin.get( &c[0],9 );
   cout << c << endl;

   cout << cin.gcount( ) << endl;
}

a

Type the letter 'a': a
1

basic_istream::get

Läser ett eller flera tecken från indataströmmen.

int_type get();

basic_istream<Char_T, Tr>& get(Char_T& Ch);
basic_istream<Char_T, Tr>& get(Char_T* str, streamsize count);
basic_istream<Char_T, Tr>& get(Char_T* str, streamsize count, Char_T delimiter);

basic_istream<Char_T, Tr>& get(basic_streambuf<Char_T, Tr>& strbuf);
basic_istream<Char_T, Tr>& get(basic_streambuf<Char_T, Tr>& strbuf, Char_T delimiter);

Parameterar

count
Antalet tecken som ska läsas från strbuf.

delimiter
Tecknet som ska avsluta läsningen om det påträffas före count.

str
En sträng som ska skrivas i.

Ch
Ett tecken att hämta.

strbuf
En buffert där du kan skriva.

Returvärde

Den parameterlösa formen av get returnerar elementet som läse som ett heltal eller slutet av filen. De återstående formulären returnerar strömmen (*this).

Anmärkningar

Den första oformaterade indatafunktionen extraherar om möjligt ett element som om möjligt genom att rdbuf->sbumpcreturnera . Annars returneras traits_type::eof. Om funktionen inte extraherar något element anropas setstate(failbit). Mer information finns i setstate.

Den andra funktionen extraherar elementet int_typemeta på samma sätt. Om meta det jämförs med traits_type::eofanropar setstate(failbit)funktionen . Annars lagras traits_type::to_char_type(meta) den i Ch. Funktionen returnerar *this. Mer information finns i to_char_type.

Den tredje funktionen returnerar get(str, count, widen('\n')).

Den fjärde funktionen extraherar upp till count - 1 element och lagrar dem i matrisen från och med str. Den lagrar char_type alltid efter alla extraherade element som lagras. I testordningen stoppas extrahering:

• I slutet av filen.

• När funktionen extraherar ett element som jämförs med delimiter. I det här fallet sätts elementet tillbaka till den kontrollerade sekvensen.

• När funktionen har extraherat count - 1 element.

Om funktionen inte extraherar några element anropas setstate(failbit). I vilket fall som helst returneras *this.

Den femte funktionen returnerar get(strbuf, widen('\n')).

Den sjätte funktionen extraherar element och infogar dem i strbuf. Extrahering stoppas i slutet av filen eller på ett element som jämförs delimitermed , som inte extraheras. Det stoppar också, utan att extrahera det aktuella elementet, om en insättning misslyckas eller genererar ett undantag (som fångas men inte återväxtas). Om funktionen inte extraherar några element anropas setstate(failbit). I vilket fall som helst returnerar *thisfunktionen .

Exempel

// basic_istream_get.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10];

   c[0] = cin.get( );
   cin.get( c[1] );
   cin.get( &c[2],3 );
   cin.get( &c[4], 4, '7' );

   cout << c << endl;
}

1111

basic_istream::getline

Hämtar en rad från indataströmmen.

basic_istream<Char_T, Tr>& getline(
    char_type* str,
    streamsize count);

basic_istream<Char_T, Tr>& getline(
    char_type* str,
    streamsize count,
    char_type delimiter);

Parameterar

count
Antalet tecken som ska läsas från strbuf.

delimiter
Tecknet som ska avsluta läsningen om det påträffas före count.

str
En sträng som ska skrivas i.

Returvärde

Strömmen (*this).

Anmärkningar

Den första av dessa oformaterade indatafunktioner returnerar getline(str, count, widen('\n')).

Den andra funktionen extraherar upp till count - 1 element och lagrar dem i matrisen från och med str. Den lagrar alltid strängavslutstecknet efter alla extraherade element som lagras. I testordningen stoppas extrahering:

• I slutet av filen.

• När funktionen extraherar ett element som jämförs med delimiter. I det här fallet läggs elementet inte tillbaka och läggs inte till i den kontrollerade sekvensen.

• När funktionen har extraherat count - 1 element.

Om funktionen inte extraherar några element eller count - 1 element anropas setstate(failbit). I vilket fall som helst returneras *this. Mer information finns i setstate.

Exempel

// basic_istream_getline.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10];

   cin.getline( &c[0], 5, '2' );
   cout << c << endl;
}

121

basic_istream::ignore

Gör att ett antal element hoppas över från den aktuella läspositionen.

basic_istream<Char_T, Tr>& ignore(
    streamsize count = 1,
    int_type delimiter = traits_type::eof());

Parameterar

count
Antalet element som ska hoppa från den aktuella läspositionen.

delimiter
Det element som, om det påträffas före antal, orsakar ignore att returnera och tillåter att alla element efter delimiter läse.

Returvärde

Strömmen (*this).

Anmärkningar

Den oformaterade indatafunktionen extraherar upp till count element och tar bort dem. Om count är lika numeric_limits<int>::maxmed tas det dock som godtyckligt stort. Extrahering stoppas tidigt i slutet av filen eller på ett element Ch som traits_type::to_int_type(Ch) jämförs delimiter med (som också extraheras). Funktionen returnerar *this. Mer information finns i to_int_type.

Exempel

// basic_istream_ignore.cpp
// compile with: /EHsc
#include <iostream>
int main( )
{
   using namespace std;
   char chararray[10];
   cout << "Type 'abcdef': ";
   cin.ignore( 5, 'c' );
   cin >> chararray;
   cout << chararray;
}

Type 'abcdef': abcdef
def

basic_istream::operator>>

Anropar en funktion på indataströmmen eller läser formaterade data från indataströmmen.

basic_istream& operator>>(basic_istream& (* Pfn)(basic_istream&));
basic_istream& operator>>(ios_base& (* Pfn)(ios_base&));
basic_istream& operator>>(basic_ios<Char_T, Tr>& (* Pfn)(basic_ios<Char_T, Tr>&));
basic_istream& operator>>(basic_streambuf<Char_T, Tr>* strbuf);
basic_istream& operator>>(bool& val);
basic_istream& operator>>(short& val);
basic_istream& operator>>(unsigned short& val);
basic_istream& operator>>(int& val);
basic_istream& operator>>(unsigned int& val);
basic_istream& operator>>(long& val);
basic_istream& operator>>(unsigned long& val);
basic_istream& operator>>(long long& val);
basic_istream& operator>>(unsigned long long& val);
basic_istream& operator>>(void *& val);
basic_istream& operator>>(float& val);
basic_istream& operator>>(double& val);
basic_istream& operator>>(long double& val);

Parameterar

Pfn
En funktionspekare.

strbuf
Ett objekt av typen stream_buf.

val
Värdet som ska läsas från strömmen.

Returvärde

Strömmen (*this).

Anmärkningar

Rubriken <istream> definierar också flera globala extraheringsoperatorer. Mer information finns i operator>> (<istream>).

Den första medlemsfunktionen säkerställer att ett uttryck för formuläret istr >> ws anropar ws(istr)och sedan returnerar *this. Mer information finns i ws.

Den andra och tredje funktionen ser till att andra manipulatorer, till exempel hex, beter sig på samma sätt. De återstående funktionerna är de formaterade indatafunktionerna.

Funktionen:

basic_istream& operator>>(
    basic_streambuf<Char_T, Tr>* strbuf);

extraherar element, om strbuf inte är en nullpekare, och infogar dem i strbuf. Extrahering stoppas i slutet av filen. Det slutar också utan att extrahera det aktuella elementet, om en infogning misslyckas eller genererar ett undantag (som fångas men inte återväxtas). Om funktionen inte extraherar några element anropas setstate(failbit). I vilket fall som helst returnerar *thisfunktionen . Mer information finns i setstate.

Funktionen:

basic_istream& operator>>(bool& val);

extraherar ett fält och konverterar det till ett booleskt värde genom att anropa use_facet< num_get<Char_T, InIt>(getloc).get( InIt(rdbuf), Init(0), *this, getloc, val). InIt Här definieras som istreambuf_iterator<Char_T, Tr>. Funktionen returnerar *this.

Mer information finns i use_facet, getloc, get, rdbufoch istreambuf_iterator.

Var och en av funktionerna:

basic_istream& operator>>(short& val);
basic_istream& operator>>(unsigned short& val);
basic_istream& operator>>(int& val);
basic_istream& operator>>(unsigned int& val);
basic_istream& operator>>(long& val);
basic_istream& operator>>(unsigned long& val);
basic_istream& operator>>(long long& val);
basic_istream& operator>>(unsigned long long& val);
basic_istream& operator>>(void *& val);

extrahera ett fält och konvertera det till ett numeriskt värde genom att anropa use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). InIt Här definieras som istreambuf_iterator<Char_T, Tr>, och val har typen long, unsigned longeller void * efter behov.

Om det konverterade värdet inte kan representeras som typen av valanropar setstate(failbit)funktionen . I vilket fall som helst returnerar *thisfunktionen . Mer information finns i setstate.

Var och en av funktionerna:

basic_istream& operator>>(float& val);
basic_istream& operator>>(double& val);
basic_istream& operator>>(long double& val);

extrahera ett fält och konvertera det till ett numeriskt värde genom att anropa use_facet<num_get<Char_T, InIt>(getloc).get(InIt(rdbuf), Init(0), *this, getloc, val). InIt Här definieras som istreambuf_iterator<Char_T, Tr>och val har typ double eller long double efter behov.

Om det konverterade värdet inte kan representeras som typen av valanropar setstate(failbit)funktionen . I vilket fall som helst returneras *this.

Exempel

// istream_basic_istream_op_is.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;

ios_base& hex2( ios_base& ib )
{
   ib.unsetf( ios_base::dec );
   ib.setf( ios_base::hex );
   return ib;
}

basic_istream<char, char_traits<char> >& somefunc(basic_istream<char, char_traits<char> > &i)
{
   if ( i == cin )
   {
      cerr << "i is cin" << endl;
   }
   return i;
}

int main( )
{
   int i = 0;
   cin >> somefunc;
   cin >> i;
   cout << i << endl;
   cin >> hex2;
   cin >> i;
   cout << i << endl;
}

basic_istream::operator=

Tilldelar basic_istream operatorn till höger om det här objektet. Det är en flytttilldelning som involverar en rvalue referens som inte lämnar kvar en kopia.

basic_istream& operator=(basic_istream&& right);

Parameterar

right
En rvalue referens till ett basic_ifstream objekt.

Returvärde

Returnerar *this.

Anmärkningar

Medlemsoperatorn anropar swap(right).

basic_istream::peek

Returnerar nästa tecken som ska läsas.

int_type peek();

Returvärde

Nästa tecken som ska läsas.

Anmärkningar

Den oformaterade indatafunktionen extraherar om möjligt ett element som om möjligt genom att rdbuf->sgetcreturnera . Annars returneras traits_type::eof. Mer information finns i sgetc och eof.

Exempel

// basic_istream_peek.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2;
   cout << "Type 'abcde': ";

   c2 = cin.peek( );
   cin.getline( &c[0], 9 );

   cout << c2 << " " << c << endl;
}

abcde

Type 'abcde': abcde
a abcde

basic_istream::putback

Placerar ett angivet tecken i strömmen.

basic_istream<Char_T, Tr>& putback(
    char_type Ch);

Parameterar

Ch
Ett tecken som ska läggas tillbaka i strömmen.

Returvärde

Strömmen (*this).

Anmärkningar

Den oformaterade indatafunktionen återställer Ch, om möjligt, som genom att anropa rdbuf->sputbackc. Om rdbuf är en null-pekare eller om anropet till sputbackc returnerar traits_type::eofanropar setstate(badbit)funktionen . I vilket fall som helst returneras *this.

Mer information finns i rdbuf, sputbackc, eofoch setstate.

Exempel

// basic_istream_putback.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2, c3;

   c2 = cin.get( );
   c3 = cin.get( );
   cin.putback( c2 );
   cin.getline( &c[0], 9 );
   cout << c << endl;
}

qwq

basic_istream::read

Läser ett angivet antal tecken från strömmen och lagrar dem i en matris.

Den här metoden är potentiellt osäker eftersom den förlitar sig på anroparen för att kontrollera att de anförda värdena är korrekta.

basic_istream<Char_T, Tr>& read(
    char_type* str,
    streamsize count);

Parameterar

str
Matrisen där tecknen ska läsas.

count
Antalet tecken som ska läsas.

Returvärde

Strömmen ( *this).

Anmärkningar

Den oformaterade indatafunktionen extraherar upp till count element och lagrar dem i matrisen från och med str. Extrahering stoppas tidigt i slutet av filen, i vilket fall funktionen anropar setstate(failbit). I vilket fall som helst returneras *this. Mer information finns i setstate.

Exempel

// basic_istream_read.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main()
{
    char c[10];
    int count = 5;

    cout << "Type 'abcde': ";

    // Note: cin::read is potentially unsafe, consider
    // using cin::_Read_s instead.
    cin.read(&c[0], count);
    c[count] = 0;

    cout << c << endl;
}

abcde

Type 'abcde': abcde
abcde

basic_istream::readsome

Läser det angivna antalet teckenvärden.

Den här metoden är potentiellt osäker eftersom den förlitar sig på anroparen för att kontrollera att de anförda värdena är korrekta.

streamsize readsome(
    char_type* str,
    streamsize count);

Parameterar

str
Matrisen där readsome de tecken som den läser lagras.

count
Antalet tecken som ska läsas.

Returvärde

Antalet tecken som faktiskt lästs, gcount.

Anmärkningar

Den här oformaterade indatafunktionen extraherar upp till count element från indataströmmen och lagrar dem i matrisen str.

Den här funktionen väntar inte på indata. Den läser alla tillgängliga data.

Exempel

// basic_istream_readsome.cpp
// compile with: /EHsc /W3
#include <iostream>
using namespace std;

int main( )
{
   char c[10];
   int count = 5;

   cout << "Type 'abcdefgh': ";

   // cin.read blocks until user types input.
   // Note: cin::read is potentially unsafe, consider
   // using cin::_Read_s instead.
   cin.read(&c[0], 2);

   // Note: cin::readsome is potentially unsafe, consider
   // using cin::_Readsome_s instead.
   int n = cin.readsome(&c[0], count);  // C4996
   c[n] = 0;
   cout << n << " characters read" << endl;
   cout << c << endl;
}

basic_istream::seekg

Flyttar läspositionen i en ström.

basic_istream<Char_T, Tr>& seekg(pos_type pos);

basic_istream<Char_T, Tr>& seekg(off_type off, ios_base::seekdir way);

Parameterar

pos
Den absoluta position där läspekaren ska flyttas.

off
En förskjutning för att flytta läspekaren i förhållande till way.

way
En av ios_base::seekdir uppräkningarna.

Returvärde

Strömmen (*this).

Anmärkningar

Den första medlemsfunktionen utför en absolut sökfunktion, den andra medlemsfunktionen utför en relativ sökfunktion.

Om fail är falseanropar newpos = rdbuf->pubseekpos(pos)den första medlemsfunktionen , för ett pos_type tillfälligt objekt newpos. Om fail är falseanropar newpos = rdbuf->pubseekoff( off, way)den andra funktionen . I båda fallen, om (off_type)newpos == (off_type)(-1) (positioneringsåtgärden misslyckas), anropar istr.setstate(failbit)funktionen . Båda funktionerna returnerar *this.

Om fail är truegör medlemsfunktionerna ingenting.

Mer information finns i rdbuf, pubseekpos, pubseekoffoch setstate.

Exempel

// basic_istream_seekg.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
   using namespace std;
   ifstream file;
   char c, c1;

   file.open( "basic_istream_seekg.txt" );
   file.seekg(2);   // seek to position 2
   file >> c;
   cout << c << endl;
}

basic_istream::sentry

Den kapslade klassen beskriver ett objekt vars deklaration strukturerar de formaterade och oformaterade indatafunktionerna.

class sentry {
   public:
   explicit sentry(
      basic_istream<Char_T, Tr>& _Istr,
      bool _Noskip = false);
   operator bool() const;
   };

Anmärkningar

Om _Istr.good är true, konstruktorn:

• Anropar _Istr.tie->flush om _Istr.tie inte är en null-pekare.

• Anropar ws(_Istr) effektivt om _Istr.flags & skipws är icke-zero.

Om konstruktorn efter någon sådan förberedelse _Istr.good är falseanropar _Istr.setstate(failbit)konstruktorn . I vilket fall som helst lagrar konstruktorn värdet som returneras av _Istr.good i status. Ett senare anrop för att operator bool leverera det här lagrade värdet.

Mer information finns i good, , tieflush, ws, flags, skipwsoch setstate.

basic_istream::swap

Utbyter innehållet i två basic_istream objekt.

void swap(basic_istream& right);

Parameterar

right
En lvalue referens till ett basic_istream objekt.

Anmärkningar

Medlemsfunktionen anropar basic_ios::swap(right). Det utbyter också extraheringsantalet med extraheringsantalet för right. Mer information finns i basic_ios::swap.

basic_istream::sync

Synkroniserar strömmens associerade indataenhet med strömmens buffert.

int sync();

Returvärde

Om rdbuf är en null-pekare returnerar funktionen -1. Annars anropas rdbuf->pubsync. Om det anropet returnerar -1 anropar setstate(badbit) funktionen och returnerar -1. Annars returnerar funktionen noll. Mer information finns i pubsync och setstate.

basic_istream::tellg

Rapporterar den aktuella läspositionen i strömmen.

pos_type tellg();

Returvärde

Den aktuella positionen i strömmen.

Anmärkningar

Om fail är falsereturnerar rdbuf->pubseekoff(0, cur, in)medlemsfunktionen . Annars returneras pos_type(-1). Mer information finns i rdbuf och pubseekoff.

Exempel

// basic_istream_tellg.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main()
{
    using namespace std;
    ifstream file;
    char c;
    streamoff i;

    file.open("basic_istream_tellg.txt");
    i = file.tellg();
    file >> c;
    cout << c << " " << i << endl;

    i = file.tellg();
    file >> c;
    cout << c << " " << i << endl;
}

basic_istream::unget

Placerar tillbaka det senast lästa tecknet i strömmen.

basic_istream<Char_T, Tr>& unget();

Returvärde

Strömmen (*this).

Anmärkningar

Den oformaterade indatafunktionen placerar tillbaka det tidigare elementet i strömmen, om möjligt, som genom att anropa rdbuf->sungetc Om rdbuf är en null-pekare eller om anropet till sungetc returnerar traits_type::eofanropar setstate(badbit)funktionen . I vilket fall som helst returneras *this.

Mer information finns i sungetc, eofoch setstate. Och information om hur unget det kan misslyckas finns i basic_streambuf::sungetc.

Exempel

// basic_istream_unget.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

int main( )
{
   char c[10], c2;

   cout << "Type 'abc': ";
   c2 = cin.get( );
   cin.unget( );
   cin.getline( &c[0], 9 );
   cout << c << endl;
}

abc

Type 'abc': abc
abc

Se även

Trådsäkerhet i C++ Standard Library
iostream Programmering
iostreams Konventioner