Следующий пост -

std::basic_ifstream.

Рубрика: fstream, Дата: 8 August, 2013, Автор:

Класс шаблон входной файловый поток.

Унаследованые члены ios_base::fmtflags

#include <iostream>
using std::cout;//содержит в себе ios, а следовательно и ios_base
using std::endl;
using std::ios_base;//базовый класс для ios
using std::ios;//класс наследник от ios_base
using std::hex;//матипулятор 16речное значение
using std::showbase;//манипулятор

int main()
{
	//Использование класса со членами контантами
	cout.setf(ios_base::hex,ios_base::basefield);
	cout.setf(ios_base::showbase);
	cout <<100<<endl;

	//Использование класса наследника с наследоваными константами
	cout.setf(ios::hex,ios::basefield);
	cout.setf(ios::showbase);
	cout <<100<<endl;

	//использование как члена объекта
	cout.setf(cout.hex,cout.basefield);
	cout.setf(cout.showbase);
	cout <<100<<endl;

	//использование как типа
	ios_base::fmtflags fm;//создание типа fmtflags.
	fm=cout.flags();//установка базового флага
	fm &= ~cout.basefield;//эта от фигня не понятно что но похоже на деструктор
	fm |= cout.hex;//установка шестнадцатеричного чегото
	fm |= cout.showbase;//а это вообще не понятно что показ базы
	cout.flags(fm);//установка видимо флага
	cout <<100<<endl;//вывод результатов

	//с  использованием манипуляторов
	cout <<hex<<showbase<<100<<endl;

	return 0;
}

унаследован istream::sentry.

Эта фигня конструирует как то объект, ну по крайней мере обрывает пробелы

#include <iostream>
using std::cout;
using std::endl;
using std::istream;
#include <string>
using std::string;
#include <locale>
using std::isspace;
using std::isdigit;
#include <sstream>
using std::stringstream;

struct Phone
{
	string digits;
};

//пользовательский экстрактор для Phone
istream& operator>>(istream& in, Phone& a)
{
	istream::sentry s(in);//создание часового
	if(s)//если есть с
		while(in.good())//пока гуд поток
		{
			char c=in.get();//считать символ
			cout <<"c= "<<c<<endl;
			//да каким то макаром пробелы оборвались.
			//да действительно функция sentry обрывает пробелы.
			if(isspace(c,in.getloc()))//выход из цикла если пробел
			{
				cout <<"Mu tyt"<<endl;
				break;
			}
			if(isdigit(c,in.getloc())) a.digits+=c;//присваиваем строку
		}
	return in;//вернуть поток
}

int main()
{
	stringstream p("     5323424234");//инициализация строкового потока
	Phone ph;
	p >>ph;//считать
	cout <<ph.digits<<endl;//переопределен и считает только числа

	return 0;
}

 

Открытые члены функции

Constructors basic_ifstream::basic_ifstream()

#include <iostream>
using std::cout;
using std::endl;
using std::cerr;
#include <fstream>
using std::ifstream;

int main()
{
	//ifstream унаследованая константа от ios_base ios
	ifstream iff("text.txt",ifstream::in);

	char c=iff.get();//считать символ из потока

	while(iff.good())
	{
		cout <<c;//вывод символа
		c=iff.get();//считать символ в поток
	}

	iff.close();//закрытие потока

	return 0;
}

 

basic_ifstream::open()

Функция открытия файлового потока.

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream iff;//инициализация пустого потока

	iff.open("text.txt",ifstream::in);//открытие файлового потока

	char c=iff.get();//считать символ
	while(iff.good())
	{
		cout <<c;
		c=iff.get();
	}

	iff.close();//закрытие файлового потока

	return 0;
}

 

basic_ifstream::if_open()

Функция возвращает true если поток открыть, и false если нет

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream iff("text.txt");

	if(iff.is_open())
	{
		char c=iff.get();
		while(iff.good())
		{
			cout <<c;
			c=iff.get();
		}
	}
	else
	{
		cout <<"file don't open"<<endl;
	}

	return 0;
}

 

basic_ifstream::close()

Функция закрывает файловый поток.

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream iff("text.txt");

	char c=iff.get();
	while(iff.good())
	{
		cout <<c;
		c=iff.get();
	}

	//закрытие файлового потока
	iff.close();

	return 0;
}

basic_ifstream::rdbuf()

Функция возвращает буфер буфер объекта или хз что.

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;
using std::filebuf;//буфер объекта

int main()
{
	//чтение файла в бинарном режиме
	ifstream iff("text.txt",ifstream::binary);

	//создать указатель на асоциацию объекта
	filebuf* pbuf=iff.rdbuf();//указатель на буфер объекта

	//получить размер файла используем член буфера
	size_t size=pbuf->pubseekoff(0,iff.end,iff.in);
	pbuf->pubseekpos(0,iff.in);

	//выделяем память для содержимого буфера
	char* buffer=new char[size];

	//получить содержимое файла
	pbuf->sgetn(buffer,size);

	iff.close();//закрыть поток

	//вывести буфер
	cout.write(buffer,size);

	//высвободить память
	delete [] buffer;

	return 0;
}

 

basic_ifstream::swap()

Функция обменивает местами потоки.

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream iff("text.txt",ifstream::in);
	ifstream foo;

	iff.swap(foo);

	if(foo.is_open())
	{
		char c=foo.get();
		while(foo.good())
		{
			cout <<c;
			c=foo.get();
		}
	}
	else
	{
		cout <<"don't open file"<<endl;
	}

	return 0;
}

 

Функции унаследованы от basic_istream

operator>>()

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
using std::hex;

int main()
{
	int number;
	cout <<"Enter a number"<<endl;
	cin >>number;
	cout <<number<<endl;
	cout <<"Enter a hex number"<<endl;
	cin >>hex>>number;
	cout <<number<<endl;

	return 0;
}

 

basic_istream::gcount()

Возвращает количество символов в потоке.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
	char mass[20];

	cout <<"vvedite clovo"<<endl;
	cin.getline(mass,20);

	cout <<"kolichectvo cimvolov - "<<cin.gcount()<<endl;

	return 0;
}

 

basic_istream::get()

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <fstream>
using std::ifstream;

int main()
{
	char mass[256];
	cout <<"Enter a name of file ... ";
	cin.get(mass,256);//прочитать имя из потока в mass

	//открыть файловый поток
	ifstream f(mass);

	while(f.good())
	{
		char c=f.get();
		if(f.good())//если поток хорош то вывод с
			cout <<c;
	}

	//закрыть поток
	f.close();

	return 0;
}

 

basic_istream::getline()

Функция считывает строку вроде как.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;

int main()
{
	char mass[256];

	cout <<"Enter your name ... ";
	cin.getline(mass,256);
	cout <<"Your name is "<<mass<<endl;

	cout <<"Enter your favorite move ... ";
	cin.getline(mass,256);
	cout <<"Your move is "<<mass<<endl;

	return 0;
}

 

basic_istream::ignore()

игнорирует количество символов.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
	char n1, n2;

	cout <<"Enter your name and sename ... "<<endl;
	n1=cin.get();//читает один символ
	cin.ignore(256,' ');//игнорировать 256 символов до пробела
	n2=cin.get();//читаем второй символ

	//вывод результатов
	cout <<n1<<' '<<n2<<endl;

	return 0;
}

 

basic_istream::peek();

Функция возвращает следующий символ который в потоке.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <string>
using std::string;

int main()
{
	cout <<"Enter number or word ... ";

	char c=cin.peek();

	if((c>='0')&&(c<='9'))//число
	{
		int n;
		cin >>n;
		cout <<"you enter a number: "<<n<<endl;
	}
	else//строка
	{
		string str;
		getline(cin,str);
		cout <<"you enter a word: "<<str<<endl;
	}

	return 0;
}

 

basic_istream::read()

Читает в переменную из потока количество символов.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <fstream>
using std::ifstream;

int main()
{
	//открываем файл в бинарном режиме
	ifstream f("text.txt",ifstream::binary);

	if(f)//если удалось открыть то выполняем действия
	{
		f.seekg(0,f.end);
		int l=f.tellg();
		f.seekg(0,f.beg);

		char* buff=new char[l];
		cout <<"l= "<<l<<endl;

		f.read(buff,l);//прочитаем в буфер количестов l

		if(f)
		{
			cout <<"read all succefully."<<endl;
		}
		else
		{
			cout <<"read charecters "<<f.gcount()<<endl;
		}

		//закрыть файловый поток
		f.close();
	}

	return 0;
}

 

basic_istream::putback()

Функция помещает символ обратно в поток

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <string>
using std::string;

int main()
{
	cout <<"vvedite number or word ... ";

	char c=cin.get();

	if((c>='0')&&(c<='9'))//номер
	{
		cin.putback(c);//добавить назад в поток символ
		int n;
		cin >>n;
		cout <<"n= "<<n<<endl;
	}
	else//строка
	{
		cin.putback(c);//помещение назад в поток символа
		string s;
		getline(cin,s);
		cout <<"s= "<<s<<endl;
	}

	return 0;
}

 

basic_ifstream::unget()

Помещает обратно в поток

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <string>
using std::string;

int main()
{
	cout <<"Enter word or number ... ";
	char c=cin.get();

	if((c>='0')&&(c<='0'))
	{
		cin.unget();//помещение назад изьятого символа
		int n;
		cin >>n;
		cout <<"n= "<<n<<endl;
	}
	else
	{
		cin.unget();//помещение назад изьятого символа
		string s;
		cin >>s;
		cout <<"s= "<<s<<endl;
	}

	return 0;
}

 

basic_istream::tellg() и besic_istream::seekg()

tellg() возвращает позицию во входной последовательности, а seekg() устанавливает в позицию

// read a file into memory
#include <iostream>     // std::cout
#include <fstream>      // std::ifstream

int main () {
  std::ifstream is ("text.txt", std::ifstream::binary);
  if (is) {
    // get length of file:
    is.seekg (0, is.end);//ставит позицию в конец
    int length = is.tellg();//возвращает позицию во входной последовательности
    is.seekg (0, is.beg);//ставит позицию на начало в потоке

    // allocate memory:
    char * buffer = new char [length];

    // read data as a block:
    is.read (buffer,length);

    is.close();

    // print content:
    std::cout.write (buffer,length);

    delete[] buffer;
  }

  return 0;
}

 

basic_istream::sync()

Функция синхронизирует поток.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;

int main()
{
	char n, n1;

	cout <<"Enter two words ... "<<endl;

	n=cin.get();
	cin.sync();//переход на следующее слово

	n1=cin.get();

	cout <<"n= "<<n<<endl;
	cout <<"n1= "<<n1<<endl;

	return 0;
}

 

Функции наслоедованые от basic_ios

basic_ios::good()

Проверяет состояние потока.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <sstream>
using std::stringstream;

void print_state(const std::ios& stream)
{
	cout <<" good()= "<<stream.good();
	cout <<" eof()= "<<stream.eof();
	cout <<" fail()= "<<stream.fail();
	cout <<" bad()= "<<stream.bad();
}

int main()
{
	stringstream stream;

	stream.clear(stream.goodbit);//установка в good()
	cout <<"godbit= "; print_state(stream); cout <<endl;

	stream.clear(stream.eofbit);//установка в еоф бит
	cout <<"eofbit= "; print_state(stream); cout <<endl;

	stream.clear(stream.failbit);//установка в failbit
	cout <<"failbit= "; print_state(stream); cout <<endl;

	stream.clear(stream.badbit);//установка в плохой бит
	cout <<"failbit= "; print_state(stream); cout <<endl;

	return 0;
}

 

basic_ios::operator!()

Это оператор показывает состояние дескриптора

#include <iostream>
using std::cout;
using std::endl;
using std::cerr;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream f;
	f.open("test.txt");
	if(!f)
		cerr <<"don't open file"<<endl;

	return 0;
}

 

basic_ios::operator bool()

Так же походу используется для проверки состоятния дескриптора.

#include <iostream>
using std::cout;
using std::cin;
using std::cerr;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream f;
	f.open("test.txt");

	if(f)
	{
		//read file
	}
	else
		cerr <<"don't open file"<<endl;

	return 0;
}

 

basic_ios::rdstate()

Хз не понятно что оно возвращает, но явно какое то состояние потока.

#include <iostream>
using std::cerr;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream f;
	f.open("test.txt");

	if((f.rdstate() & ifstream::failbit)!=0)
		cerr <<"don't open file"<<endl;

	return 0;
}

 

basic_iostream::clear()

Функция делает поток фиг его знает хорошим. Тоже как то состояние ошибки чтоль удаляет хз.

#include <iostream>
using std::cout;
using std::cerr;
using std::endl;
#include <fstream>
using std::fstream;

int main()
{
	char buff[80];
	fstream f;

	f.open("text.txt",fstream::in);//открываем для чтения

	f <<"test";

	if(f.fail())
	{
		cout <<"Error writing to text.txt"<<endl;
		f.clear();//очищает поток 
	}

	f.getline(buff,80);
	cout <<"buff= "<<buff<<endl;

	return 0;
}

 

basic_ios::copyfmt()

Копирует как бы один поток в другой

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ofstream;

int main()
{
	ofstream f;
	f.open("text.txt");

	cout.fill('*');
	cout.width(10);//10 шириной
	f.copyfmt(cout);//скопировало один поток в другой

	cout <<"40";
	f <<"40";

	return 0;
}

 

basic_iostream::fill()

Получает/устанавливает символ заполнения.

#include <iostream>
using std::cout;
using std::endl;

int main()
{
	char prev;

	cout.width(10);
	cout <<"40"<<endl;

	prev=cout.fill('x');
	cout.width(10);
	cout <<"40"<<endl;

	//установка обратно fill или хз.
	cout.fill(prev);

	return 0;
}

 

basic_ios::exceptions

Хз. но как то устанавливает исключение для файла

#include <iostream>
using std::cerr;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream f;
	//установка видимо реакции исключения
	f.exceptions(ifstream::failbit | ifstream::badbit);

	try
	{
		f.open("test.txt");
		while(!f.eof()) f.get();
	}
	catch(ifstream::failure e)
	{
		cerr <<"Exceptions opening/reading file"<<endl;
	}

	f.close();

	return 0;
}

 

basic_ios::imbue()

Функция в качестве параметра принимает локаль.

#include <iostream>
using std::cout;
using std::endl;
#include <locale>
using std::locale;

int main()
{
	locale l("");//получить глобальную локаль
	cout.imbue(l);//установить глобальную локаль
	cout <<"3.1453434"<<endl;

	return 0;
}

 

basic_ios::tie()

связывает потоки или хз.

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
using std::ostream;
#include <fstream>
using std::ofstream;

int main()
{
	ostream* p;//указатель на выходной поток
	ofstream f;//создание выходного файлового потока
	f.open("text.txt");//открытие файла

	cout <<"tie exemple"<<endl;

	//добавление в поток строчки
	*cin.tie() <<"This is inserted into cout"<<endl;
	p=cin.tie(&f);//присвоить выходному потоку
	//добавление в поток другой строчки
	*cin.tie() <<"This is inserted into file axa"<<endl;
	cin.tie(p);//присвоить файловому потоку

	f.close();//закрытие файлового потока

	return 0;
}

 

basic_ios::rdbuf()

Получить/установить буфер потока. Она как то буферы наверно подменивает чтоли.

#include <iostream>
using std::cout;
using std::streambuf;
using std::endl;
#include <fstream>
using std::ofstream;

int main()
{
	streambuf *one, *two;
	ofstream f;
	f.open("text.txt");

	one=cout.rdbuf();//получить буфер объекта cout.
	two=f.rdbuf();//получить буфер файлового потока
	cout.rdbuf(two);//назначить в поток cout буфер файлового

	cout <<"This is writen to the file"<<endl;
	cout.rdbuf(one);//назначить старый буфер.
	cout <<"da mu tut"<<endl;

	f.close();//закрыть файловый поток.

	return 0;
}

 

Функции члены унаследованные от ios_base.

ios_base::flags()

Функция как то устанавливает флаги чтоли.

#include <iostream>
using std::cout;
using std::ios;
using std::endl;

int main()
{
	cout.flags(ios::right | ios::hex | ios::showbase);
	cout.width(10);
	cout <<100<<endl;

	return 0;
}

 

ios_base::setf() и ios_base::unsetf()

Функция setf() походу устанавливает флаги, а функция unsetf() похоже сбрасывает флаги.

#include <iostream>
using std::cout;
using std::endl;
using std::ios;

int main()
{  
	cout.setf(ios::hex, ios::basefield);
	cout.setf(ios::showbase);

	cout <<100<<endl;

	cout.unsetf(ios::showbase);
	cout <<100<<endl;

	return 0;
}

 

ios_base::presicion()

Функция походу отвечает за количество символов после запятой.

#include <iostream>
using std::cout;
using std::endl;
using std::ios;

int main()
{
	double p=3.14159;
	cout.unsetf(ios::floatfield);
	cout.precision(5);
	cout <<p<<endl;
	cout.precision(10);
	cout <<p<<endl;

	cout.setf(ios::fixed,ios::floatfield);
	cout <<p<<endl;

	return 0;
}

 

ios_base::width()

Задает ширину.

#include <iostream>
using std::cout;
using std::endl;
using std::left;

int main()
{
	cout <<100<<endl;

	cout.width(10);
	cout <<100<<endl;

	cout.fill('x');
	cout.width(15);
	cout <<left<<100<<endl;

	return 0;
}

 

ios_base::imbue()

Устанавливает локаль.

// imbue example
#include <iostream>     // std::cout
#include <locale>       // std::locale

int main()
{
  std::locale mylocale("");   // get global locale
  std::cout.imbue(mylocale);  // imbue global locale
  std::cout << 3.14159 << '\n';
  return 0;
}

 

ios_basic::iword()

Получить целый элемент расширяемого массива. хз. что она делает. Смотрите пример, хотя я его не понял

#include <iostream>
using std::cout;
using std::endl;
using std::ostream;
using std::cerr;

//пользовательский манипулятор
ostream& Counter(ostream& os)
{
	const static int index=os.xalloc();
	return os<<++os.iword(index);//хз что эта строчка делает
}

int main()
{
	cout <<Counter<<" one line"<<endl;
	cout <<Counter<<" two line"<<endl;
	cout <<Counter<<" three line"<<endl;

	cerr <<Counter<<" error"<<endl;

	return 0;
}

 

ios_base::pword()

Получить указатель на расширяемый элемент. Также хз. что она делает.

#include <iostream>
using std::cout;
using std::cerr;
using std::endl;
using std::clog;
using std::ios;
using std::ostream;

const int name=ios::xalloc();

void SetStreamName(ios& stream,const char* n)
{
	stream.pword(name)=const_cast<char*>(n);
}

ostream& StreamName(ostream& os)
{
	const char* n=static_cast<const char*>(os.pword(name));
	if(n) os<<n;
	else os<<"unknow";
	return os;
}

int main()
{
	SetStreamName(cout,"standart output stream");
	SetStreamName(cerr,"standart error stream");

	cout <<StreamName<<endl;
	cerr <<StreamName<<endl;
	clog <<StreamName<<endl;

	return 0;
}

 

ios_base::register_callback()

Регистрация функции обратного вызова по событию , но что она делает я хз.

#include <iostream>
using std::cout;
using std::endl;
using std::ios;
using std::ios_base;
#include <fstream>
using std::ofstream;

void test(ios::event ev, ios_base& stream, int n)
{
	switch(ev)
	{
		case stream.copyfmt_event:
			cout <<"copyfmt event"<<endl;break;
		case stream.imbue_event:
			cout <<"imbue event"<<endl;break;
		case stream.erase_event:
			cout <<"erase event"<<endl;break;
	}
}

int main()
{
	ofstream f;
	f.register_callback(test,0);
	f.imbue(cout.getloc());

	return 0;
}

 

Функция не входящая в класс swap()

Походу обменивает потоки.

#include <iostream>
using std::cout;
using std::endl;
#include <fstream>
using std::ifstream;

int main()
{
	ifstream foo("text.txt");
	ifstream bar;
	
	swap(foo,bar);

	char c=bar.get();
	while(bar.good())
	{
		cout <<c;
		c=bar.get();
	}

	cout <<endl;

	bar.close();

	return 0;
}

[youtube]http://www.youtube.com/watch?v=q7Yn9MYKTXA[/youtube]

rss