C/C++

Alan85 · Отправлено: **21:18, 21-03-2009** | #61

hda0, данный метод подходит для статического текста, а если например у нас большая база данных из другого источника (с кодировкой 1251) . Да и само по себе генерация файла потом копирование информации от туда в исходники имхо костыли еще те... и не понятно как потом не запутаться что есть где смотря все это в 1251 кодировке (разве что повторно набирать тот же текст)

Drongo · Конфигурация компьютера

Цитата XEN_STRANGER:

Drongo, А твой пример при компиляции ссылается на:
error C2440: 'initializing' : cannot convert from 'char *' to 'unsigned char *' »

Ну, наверное тип передаваемого параметра сменить попробовать в unsigned char
Вместо

Код:

...
// Функция перекодировки в кирилицу
char* rus(char* st)
{
...

на такой

Код:

...
// Функция перекодировки в кирилицу
char* rus(unsigned char* st)
{
...

hda0 · Отправлено: **21:27, 21-03-2009** | #63

Без проблем. Если есть far, то там в редактировании файла можно сразу же поставить кодировку dos, и спокойно писать на русском языке, ну незнаю, просто то что я написал, занимает очень мало кода и мне например очень удобно через far писать, а вообще я думаю написать собственный редактор сразу с кодировкой dos, и с сохранением файла с расширением bat.

ganselo · Отправлено: **16:41, 27-03-2009** | #64

Вот вариант своего класса для ввода/вывода на кириллице
(для Visual C++ 5.0 и более поздних)

Код:

#ifndef CYR_IOS_H
#define CYR_IOS_H
#include <iostream>
#include <iomanip>
#include <string>
#include <windows.h>
using namespace std;

#define MAX_STR_LEN 4096

//////////////////////////////////////////////////////////////////////////////////
// Класс CyrOstream
class CyrOstream : public ostream {
	public:
		CyrOstream(_Uninitialized no_init) : ostream(no_init) {};
		CyrOstream& operator <<(_Myt& (_cdecl *_f)(_Myt&));
		CyrOstream& operator <<(ios_base& (_cdecl *_f)(ios_base& ));
		CyrOstream& operator <<(short n) { cout << n; return *this; }
		CyrOstream& operator <<(unsigned short n){ cout << n; return *this; }
		CyrOstream& operator <<(int n) { cout << n; return *this; }
		CyrOstream& operator <<(unsigned int n){ cout << n; return *this; }
		CyrOstream& operator <<(long n) { cout << n; return *this; }
		CyrOstream& operator <<(unsigned long n) { cout << n; return *this; }
		CyrOstream& operator <<(float f) { cout << f; return *this; }
		CyrOstream& operator <<(double f) { cout << f; return *this; }
		CyrOstream& operator <<(long double f) { cout << f; return *this; }
		CyrOstream& operator <<(const void* v) { cout << v; return *this; }
		CyrOstream& operator <<(const char*);
		CyrOstream& operator <<(const unsigned char* s) { operator <<((const char*)s); return *this; }
		CyrOstream& operator <<(const signed char* s) { operator <<((const char*)s); return *this; }
		CyrOstream& operator <<(char);
		CyrOstream& operator <<(unsigned char);
		CyrOstream& operator <<(signed char c) { operator <<((char)c); return *this; }
		CyrOstream& put(char);
		CyrOstream& write(const char*, int);
		CyrOstream& write(const unsigned char* s, int len) 
		{	
			write((const char*)s, len); return *this; 
		}
		// Замещение методов класса ios
		long setf(long lFlags) { return cout.setf(lFlags); }
		void unsetf(long lFlags) { cout.unsetf(lFlags); }
		char fill(char cFill) { return cout.fill(cFill); }
		char fill() { return cout.fill(); }
		int precision(int np) { return cout.precision(np); }
		int precision() const { return cout.precision(); }
		int width(int nw) { return cout.width(nw); }
		int width() const { return cout.width(); }
		int rdstate() const { return cout.rdstate(); }
		long flags() const { return cout.flags(); }
		long flags(long _l) { return cout.flags(_l); }
		streambuf* rdbuf() const { return cout.rdbuf(); }
		// Дружественная функция для поддержки параметризованных манипуляторов
		friend CyrOstream& operator <<(CyrOstream&, const _Smanip<int>&);
	private:
		char buf_[MAX_STR_LEN];
};

////////////////////////////////
// Шаблон для вывода типа string
template<class _E, class _Tr, class _A>
inline CyrOstream& operator <<(CyrOstream& os, const basic_string<_E, _Tr, _A>& _X) 
{
	string temp(_X);
	unsigned char symb[2];
	symb[1] = 0;
	for (int i = 0; i < temp.size(); i++) 
	{
		symb[0] = temp.at(i);
		if (symb[0] > 191)
		CharToOem((const char*)symb, (char*)symb);
		cout << symb;
	}
return os;
}

///////////////////////////////////////////////////////////
// Класс CyrIstream
class CyrIstream : public istream {
	public:
		CyrIstream(_Uninitialized no_init) : istream(no_init) {};
		CyrIstream& operator >>(ios_base& (_cdecl *_f)(ios_base& ));
		CyrIstream& operator >>(char*);
		CyrIstream& operator >>(unsigned char* s)
		{
			operator >>((char*)s); return *this;
		}
		CyrIstream& operator >>(signed char* s) 
		{
			operator >>((char*)s); return *this; 
		}
		CyrIstream& operator >>(char& c);
		CyrIstream& operator >>(unsigned char& c)
		{
			operator >>((char&)c); return *this;
		}
		CyrIstream& operator >>(signed char& c)
		{
			operator >>((char&)c); return *this;
		}
		CyrIstream& operator >>(short &n) { cin >> n; return *this; }
		CyrIstream& operator >>(unsigned short &n)
		{
			cin >> n; return *this; 
		}
		CyrIstream& operator >>(int &n) { cin >> n; return *this; }
		CyrIstream& operator >>(unsigned int &n)
		{
			cin >> n; return *this;
		}
		CyrIstream& operator >>(long &n) { cin >> n; return *this; }
		CyrIstream& operator >>(unsigned long &n)
		{
			cin >> n; return *this; 
		}
		CyrIstream& operator >>(float &f) { cin >> f; return *this; }
		CyrIstream& operator >>(double &f) { cin >> f; return *this; }
		CyrIstream& operator >>(long double &f)
		{
			cin >> f; return *this;
		}
		int get() { return cin.get(); }
		CyrIstream& get(char&);
		CyrIstream& get(char*, int, char='\n');
		CyrIstream& get(unsigned char*, int, char = '\n');
		CyrIstream& getline(char*, int, char='\n');
		CyrIstream& getline(unsigned char* pch, int nCount, char delim ='\n') 
		{
			getline((char*)pch, nCount, delim); return *this; 
		}
		CyrIstream& read(char*, int);
		CyrIstream& read(unsigned char* pch, int nCount)
		{
			read((char*)pch, nCount); return *this; 
		}
		CyrIstream& ignore(int nCount = 1, int delim = EOF)
		{
			cin.ignore(nCount, delim); return *this;
		}
		int peek() { return cin.peek(); }
		int gcount() const { return cin.gcount(); }
		CyrIstream& putback(char ch) { cin.putback(ch); return *this; }
		// Замещение методов класса ios
		void clear(int nState = 0) { cin.clear(nState); }
		long setf(long lFlags) { return cin.setf(lFlags); }
		void unsetf(long lFlags) { cin.unsetf(lFlags); }
		int rdstate() const { return cin.rdstate(); }
		long flags() const { return cin.flags(); }
		streambuf* rdbuf() const { return cin.rdbuf(); }
		// Дружественная функция для поддержки параметризованных манипуляторов
		friend CyrIstream& operator >>(CyrIstream&, const _Smanip<int>&);
	private:
		char buf_[MAX_STR_LEN];	
};

/////////////////////////////////////////////////////////////
//Шаблон для ввода типа string
template<class _E, class _Tr, class _A>
inline CyrIstream& operator >>(CyrIstream& is, basic_string<_E, _Tr, _A>& _X) 
{
	string temp;
	cin >> temp;
	unsigned int n = temp.size();
	char *buf = new char[n+1];
	temp.copy(buf, n); buf[n] = 0;
	OemToChar(buf, (char*)buf);
	_X = string(buf);
	delete [] buf;
return is;
}

CyrOstream& CyrOstream::operator << (_Myt& (_cdecl *_f)(_Myt&))
{
	cout << _f; return *this;
}
CyrOstream& CyrOstream::operator << (ios_base& (_cdecl *_f)(ios_base& ))
{
	cout << _f; return *this;
}

CyrOstream& CyrOstream::operator <<(const char *s)
{
	int n = strlen(s);
	strncpy(buf_, s, n); buf_[n] = 0;
	CharToOem(buf_, buf_);
	cout << buf_;
return *this;
}

CyrOstream& CyrOstream::operator <<(char c)
{
	buf_[0] = c; buf_[1] = 0;
	CharToOem(buf_, buf_);
	cout << buf_;
return *this;
}

CyrOstream& CyrOstream::operator <<(unsigned char c)
{
	unsigned char buf[2];
	buf[0] = c; buf[1] = 0;
	if (c > 191)
		CharToOem((const char*)buf, (char*)buf);
	cout << buf;
return *this;
}

CyrOstream& CyrOstream::put(char c)
{
	buf_[0] = c; buf_[1] = 0;
	CharToOem(buf_,  buf_);
	cout.put(buf_[0]);
return *this;
}

CyrOstream& CyrOstream::write(const char* s, int len)
{
	int n = strlen(s);
	strncpy(buf_, s, n); buf_[n] = 0;
	CharToOem(buf_, buf_);
	cout.write(buf_, len);
return *this;
}
CyrOstream& operator <<(CyrOstream& os, const _Smanip<int>& m)
{
	cout << m; return os;
}

CyrIstream& CyrIstream::operator >> (ios_base& (_cdecl *_f)(ios_base& ))
{
	cin >> _f; return *this;
}
CyrIstream& CyrIstream::operator >>(char* s) 
{
	string temp;
	cin >> temp;
	unsigned int n = temp.size();
	temp.copy(buf_, n); buf_[n] = 0;
	OemToChar(buf_, buf_);
	strncpy (s, buf_, n + 1);
return *this;
}

CyrIstream& CyrIstream::operator >>(char& c)
{
	cin >> buf_[0];
	buf_[1] = 0;
	OemToChar(buf_, buf_);
	c = buf_[0];
return *this;
}


CyrIstream& CyrIstream::get(char& symb)
{
	cin.get(buf_[0]);
	buf_[1] = 0;
	OemToChar(buf_, buf_);
	symb = buf_[0];
return *this;
}

CyrIstream& CyrIstream::get(char* pch, int nCount, char delim)
{
	cin.get(pch, nCount, delim);
	OemToChar(pch, pch);
return *this;
}

CyrIstream& CyrIstream::get(unsigned char* pch, int nCount, char delim)
{
	cin.get((char*)pch, nCount, delim);
	OemToChar((const char*)pch, (char*)pch);
return *this;
}

CyrIstream& CyrIstream::getline(char* pch, int nCount, char delim)
{
	cin.getline(pch, nCount, delim);
	OemToChar(pch, pch);
return *this;
}

CyrIstream& CyrIstream::read(char* pch, int nCount)
{
	cin.read(buf_, nCount);
	buf_[nCount] = 0;
	OemToChar(buf_, buf_);
	for(int i = 0; i < nCount; i++)
		pch[i] = buf_[i];
return *this;
}

CyrIstream& operator >>(CyrIstream& is, const _Smanip<int>& m) 
{
	cin >> m; return is;
}

//////////////////////////////////////////////////////////
// Глобальные объекты для ввода и вывода
CyrIstream Cin(_Noinit);
CyrOstream Cout(_Noinit);


///////////////////////////////////////////////////////////
extern CyrIstream Cin;
extern CyrOstream Cout;
#endif

#ifndef CYR_IOS_IMPLEMENTATION
	#define cin Cin
	#define cout Cout
	#define istream CyrIstream
	#define ostream CyrOstream
#endif

Вот вариант для компилятора mingw (всякие там Code::Blocks, Dev C++ и т.д)

Код:

#ifndef RUS_H_INCLUDED
#define RUS_H_INCLUDED
#include <iostream>
#include <iomanip>
#include <string>
#include <windows.h>
#define MAX_STR_LEN 4096

class CyrOstream : public std::ostream
{
    public:
        CyrOstream() : std::ostream() {}
        CyrOstream& operator <<(__ostream_type& (*__pf)(__ostream_type&))
        {
            std::cout << __pf; return *this;
        }
        CyrOstream& operator <<(__ios_type& (*__pf)(__ios_type&))
        {
            std::cout << __pf; return *this;
        }
        CyrOstream& operator <<(ios_base& (*__pf)(ios_base&))
        {
            std::cout << __pf; return *this;
        }
        CyrOstream& operator <<(short n) { std::cout << n; return *this; }
		CyrOstream& operator <<(unsigned short n) { std::cout << n; return *this; }
		CyrOstream& operator <<(int n) { std::cout << n; return *this; }
		CyrOstream& operator <<(unsigned int n) { std::cout << n; return *this; }
		CyrOstream& operator <<(long n) { std::cout << n; return *this; }
		CyrOstream& operator <<(long long n) {std::cout << n; return *this; }
		CyrOstream& operator <<(unsigned long n) { std::cout << n; return *this; }
		CyrOstream& operator <<(float f) { std::cout << f; return *this; }
		CyrOstream& operator <<(double f) { std::cout << f; return *this; }
		CyrOstream& operator <<(long double f) { std::cout << f; return *this; }
		CyrOstream& operator <<(const void* v) { std::cout << v; return *this; }
		CyrOstream& operator <<(const char*);
		CyrOstream& operator <<(const unsigned char* s) { std::cout << s; return *this;}
		CyrOstream& operator <<(const signed char* s) { std::cout << s; return *this;}
		CyrOstream& operator <<(char);
		CyrOstream& operator <<(unsigned char);
		CyrOstream& operator <<(signed char c) { operator <<((char)c); return *this; }
		CyrOstream& operator <<(std::streambuf *buf) { std::cout << buf; return *this; }

		CyrOstream& put(char);
		CyrOstream& write(const char*, int);
		CyrOstream& write(const unsigned char* s, int len);

        char fill(char cFill) { return std::cout.fill(cFill); }
		char fill() { return std::cout.fill(); }
		int precision(int np) { return std::cout.precision(np); }
		int precision() const { return std::cout.precision(); }
		int width(int nw) { return std::cout.width(nw); }
		int width() const { return std::cout.width(); }
		int rdstate() const { return std::cout.rdstate(); }

        friend CyrOstream& operator <<(CyrOstream&, std::_Setprecision __f);
		friend CyrOstream& operator <<(CyrOstream&, std::_Resetiosflags __f);
		friend CyrOstream& operator <<(CyrOstream&, std::_Setiosflags __f);
		friend CyrOstream& operator <<(CyrOstream&, std::_Setbase __f);
		friend CyrOstream& operator <<(CyrOstream&, std::_Setfill<wchar_t> __f);
		friend CyrOstream& operator <<(CyrOstream&, std::_Setw __f);

		template<typename _CharT, typename _Traits, typename _Alloc>
        friend CyrOstream& operator <<(CyrOstream& os,
            const std::basic_string<_CharT, _Traits, _Alloc>& __str);
    private:
        char buf_[MAX_STR_LEN];
};
//=======================================================================
//=======================================================================
class CyrIstream : public std::istream
{
    public:
        CyrIstream() : std::istream() {}
        CyrIstream& operator >>(ios_base& (*__pf)(ios_base&))
        {
            std::cin >> __pf; return *this;
        }
        CyrIstream& operator >>(char*);
        CyrIstream& operator >>(unsigned char* s)
		{
			operator >>((char*)s); return *this;
		}
		CyrIstream& operator >>(signed char* s)
		{
			operator >>((char*)s); return *this;
		}
		CyrIstream& operator >>(char& c);
		CyrIstream& operator >>(unsigned char& c)
		{
			operator >>((char&)c); return *this;
		}
		CyrIstream& operator >>(signed char& c)
		{
			operator >>((char&)c); return *this;
		}
		CyrIstream& operator >>(short &n) { std::cin >> n; return *this; }
		CyrIstream& operator >>(unsigned short &n)
		{
			std::cin >> n; return *this;
		}
		CyrIstream& operator >>(int &n) { std::cin >> n; return *this; }
		CyrIstream& operator >>(unsigned int &n)
		{
			std::cin >> n; return *this;
		}
		CyrIstream& operator >>(long &n) { std::cin >> n; return *this; }
		CyrIstream& operator >>(unsigned long &n)
		{
			std::cin >> n; return *this;
		}
		CyrIstream& operator >>(float &f) { std::cin >> f; return *this; }
		CyrIstream& operator >>(double &f) { std::cin >> f; return *this; }
		CyrIstream& operator >>(long double &f)
		{
			std::cin >> f; return *this;
		}
		int get() { return std::cin.get(); }
		CyrIstream& get(char&);
		CyrIstream& get(char*, int, char='\n');
		CyrIstream& get(unsigned char*, int, char = '\n');
		CyrIstream& getline(char*, int, char='\n');
		CyrIstream& getline(unsigned char* pch, int nCount, char delim ='\n')
		{
			getline((char*)pch, nCount, delim); return *this;
		}
		CyrIstream& read(char*, int);
		CyrIstream& read(unsigned char* pch, int nCount)
		{
			read((char*)pch, nCount); return *this;
		}
		CyrIstream& ignore(int nCount = 1, int delim = EOF)
		{
			std::cin.ignore(nCount, delim); return *this;
		}
		int peek() { return std::cin.peek(); }
		int gcount() const { return std::cin.gcount(); }
		CyrIstream& putback(char ch) { std::cin.putback(ch); return *this; }

		// Замещение методов класса ios
		//void clear(int nState = 0) { std::cin.clear(nState); }
		//long setf(long lFlags) { return std::cin.setf(lFlags); }
		//void unsetf(long lFlags) { std::cin.unsetf(lFlags); }
		int rdstate() const { return std::cin.rdstate(); }
		long flags() const { return std::cin.flags(); }
		std::streambuf* rdbuf() const { return std::cin.rdbuf(); }

        friend CyrIstream& operator >>(CyrIstream&, std::_Setprecision __f);
		friend CyrIstream& operator >>(CyrIstream&, std::_Resetiosflags __f);
		friend CyrIstream& operator >>(CyrIstream&, std::_Setiosflags __f);
		friend CyrIstream& operator >>(CyrIstream&, std::_Setbase __f);
		friend CyrIstream& operator >>(CyrIstream&, std::_Setfill<wchar_t> __f);
		friend CyrIstream& operator >>(CyrIstream&, std::_Setw __f);

		template<typename _CharT, typename _Traits, typename _Alloc>
        friend CyrIstream& operator >>(CyrIstream& os,
            const std::basic_string<_CharT, _Traits, _Alloc>& __str);
	private:
		char buf_[MAX_STR_LEN];
};

//=======================================================================
//Методы класса CyrOstream
//=======================================================================
CyrOstream& CyrOstream::operator <<(const char *s)
{
    int n = strlen(s);
    strncpy(buf_, s, n); buf_[n] = '\0';
    CharToOem(buf_, buf_);
    std::cout << buf_;
    return *this;
}
//=======================================================================
CyrOstream& CyrOstream::operator <<(char c)
{
	buf_[0] = c; buf_[1] = 0;
	CharToOem(buf_, buf_);
	std::cout << buf_;
return *this;
}
//=======================================================================
CyrOstream& CyrOstream::operator <<(unsigned char c)
{
	unsigned char buf[2];
	buf[0] = c; buf[1] = 0;
	if (c > 191)
		CharToOem((const char*)buf, (char*)buf);
	std::cout << buf;
    return *this;
}
//======================================================================
//======================================================================
CyrOstream& CyrOstream::put(char c)
{
    buf_[0] = c; buf_[1] = 0;
	CharToOem(buf_,  buf_);
	std::cout.put(buf_[0]);
    return *this;
}
//======================================================================
CyrOstream& CyrOstream::write(const char* s, int len)
{
	int n = strlen(s);
	strncpy(buf_, s, n); buf_[n] = 0;
	CharToOem(buf_, buf_);
	std::cout.write(buf_, len);
return *this;
}
//======================================================================
CyrOstream& CyrOstream::write(const unsigned char* s, int len)
{
    write((const char*)s, len);
    return *this;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Setprecision __f)
{
    std::cout << __f;
    return os;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Resetiosflags __f)
{
    std::cout << __f;
    return os;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Setiosflags __f)
{
    std::cout << __f;
    return os;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Setbase __f)
{
    std::cout << __f;
    return os;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Setfill<wchar_t> __f)
{
    std::cout << __f._M_c;
    return os;
}
//======================================================================
CyrOstream& operator <<(CyrOstream &os, std::_Setw __f)
{
    std::cout << __f;
    return os;
}
//======================================================================
template<typename _CharT, typename _Traits, typename _Alloc>
CyrOstream& operator <<(CyrOstream& os,
    const std::basic_string<_CharT, _Traits, _Alloc>& __str)
{
    std::string temp(__str);
	unsigned char symb[2];
	symb[1] = 0;
	for (int i = 0; i < temp.size(); i++)
	{
		symb[0] = temp.at(i);
		if (symb[0] > 191)
		CharToOem((const char*)symb, (char*)symb);
		std::cout << symb;
	}
return os;
}
//=======================================================================
//Методы класса CyrIstream
//=======================================================================
//Шаблон для ввода типа string
template<typename _CharT, typename _Traits, typename _Alloc>
inline CyrIstream& operator >>(CyrIstream& is,
            const std::basic_string<_CharT, _Traits, _Alloc>& __str)
{
	std::string temp;
	std::cin >> temp;
	unsigned int n = temp.size();
	char *buf = new char[n+1];
	temp.copy(buf, n); buf[n] = 0;
	OemToChar(buf, (char*)buf);
	__str = std::string(buf);
	delete [] buf;
return is;
}
//=======================================================================
CyrIstream& CyrIstream::operator >>(char* s)
{
	std::string temp;
	std::cin >> temp;
	unsigned int n = temp.size();
	temp.copy(buf_, n); buf_[n] = 0;
	OemToChar(buf_, buf_);
	strncpy (s, buf_, n + 1);
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::operator >>(char& c)
{
	std::cin >> buf_[0];
	buf_[1] = 0;
	OemToChar(buf_, buf_);
	c = buf_[0];
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::get(char& symb)
{
	std::cin.get(buf_[0]);
	buf_[1] = 0;
	OemToChar(buf_, buf_);
	symb = buf_[0];
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::get(char* pch, int nCount, char delim)
{
	std::cin.get(pch, nCount, delim);
	OemToChar(pch, pch);
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::get(unsigned char* pch, int nCount, char delim)
{
	std::cin.get((char*)pch, nCount, delim);
	OemToChar((const char*)pch, (char*)pch);
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::getline(char* pch, int nCount, char delim)
{
	std::cin.getline(pch, nCount, delim);
	OemToChar(pch, pch);
return *this;
}
//=======================================================================
CyrIstream& CyrIstream::read(char* pch, int nCount)
{
	std::cin.read(buf_, nCount);
	buf_[nCount] = 0;
	OemToChar(buf_, buf_);
	for(int i = 0; i < nCount; i++)
		pch[i] = buf_[i];
return *this;
}
//=======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Setprecision __f)
{
    std::cin >> __f;
    return is;
}
//======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Resetiosflags __f)
{
    std::cin >> __f;
    return is;
}
//======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Setiosflags __f)
{
    std::cin >> __f;
    return is;
}
//======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Setbase __f)
{
    std::cin >> __f;
    return is;
}
//======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Setfill<wchar_t> __f)
{
    std::cin.fill(__f._M_c);
    return is;
}
//======================================================================
CyrIstream& operator <<(CyrIstream &is, std::_Setw __f)
{
    std::cin >> __f;
    return is;
}
CyrOstream Cout;
CyrIstream Cin;
extern CyrOstream Cout;
extern CyrIstream Cin;
#endif

#ifndef RUS_H_INCLUDED_IMPLEMENTATION
	#define cout Cout
	#define cin Cin
	#define ostream CyrOstream
	#define istream CyrIstream
#endif

Ну и мб напишу для Borland'овских компиляторов.
Копируем например в rus.h код ну и вызывем так:

Код:

#include "rus.h" //смотря как назвали

int main()
{
     cout << "Кириллица" << endl;
return 0;
}

Admiral · Отправлено: **23:08, 03-04-2009** | #65

Всем привет!
Работая с функцией isdigit() (данная функция определяет - является ли символ числом), необходимо было проверять является ли её потенциальный аргументы латинским символом. При взятии от кириллического происходит крушение программы. Это подвело к тому, что данная функция и не нужна, раз идёт проверка символов то уже проще самостоятельно определить является ли символ числом.
Для корректной работы isdigit() с массивами символов, где может быть кириллица, нужно определять массив символов как unsigned char, а не просто char, по этому решения сабжа предполагает использования в двух вариантах.
Итак, имеет MS-DOS кодовую страницу 866 (Code Page 866 MS-DOS) применяемую в консольных приложениях для Виндовс.
Её всегда можно подсмотреть таким вот образом

Код:

for (int i=0;i<256;i++;)
	printf("%i %c %i\n",i ,i);
/*Во время выполнения кода пискнет спикер в корпусе
(если он конечно есть и не отключён в диспетчере устройств),
так должно быть.
Это управляющий неотображаемый символ '\a' идущий под номером 7.
Впрочем в Windows 7 не пищал.*/

Та абракадабра, которая отображается при не решённом сабже, так же находится здесь на равнее с корректными латинскими символами. На разнице их номеров и можно организовать правильное отображение

Код:

#include <stdio.h>
#define UNSIGNED

int main()
{
	int i=0;

#ifdef UNSIGNED
	unsigned char str []="ABC abc АБВ абв ЂЃ‚  Ўў Привет";
	while (str [i]!='\0')
	{
		if (((128+64)<=str[i])&&(str[i]<=(175+64)))
			str[i]=str[i]-64;

		if (((224+16)<=str[i])&&(str[i]<=(236+16)))
			str[i]=str[i]-16;

		printf("%c",str[i]);

		i++;
	}

#else
	char str []="ABC abc АБВ абв ЂЃ‚  Ўў Привет";
	while (str [i]!='\0')
	{
		if ((-64<=str[i]) && (str[i]<=-17))
			str[i]=str[i]+192;
		
		if ((-16<=str[i]) && (str[i]<=-1))
			str[i]=str[i]+240;

		printf("%c",str[i]);
		i++;
	}
#endif
	return 0;
}

Для тех кому не знакома конструкция #ifdef #else #endif: она на выбор предлагает скомпилировать один из участков кода, в данном случаи когда определен UNSIGNED (#define UNSIGNED) компилируется участок кода до #ifdef, между #ifdef /#else и после #endif.

strlen ведь не по зубам подсчитать длину unsigned char? Если всё же по зубам пожалуйста поправьте, а то в одной программе, где много strlen и используется isdigit() и массив char, при переходе на unsigned char не хотелось бы отказываться от неё.
Пока ориентируемся на управляющий символ конца строки '\0' и используем цикл while
В случаи char массива можно использовать цикл for, предельное значение подскажет функция strlen - for (int i=0; strlen(str); i++)

Единственное что, буква Ё и другие кириллические символы идущие в кодовой странице MS-DOS 866 с кодами после 240, не учтены в коде данной программы.

P.S.

Спасибо за внимание.

NYX · Отправлено: **01:16, 16-12-2009** | #66

Ну вы ребят даете, громоздкие коды такие

Сори за остроумность, на на мой взгляд загон из Win в Koi того не стоит

Мона сделать простую функцию, аргументом которой текст Koi, а возвратом будет Win

Это пишется в пару строк, что то типо того:

Код:

char KoiWin(char sym)
{
shar *cWin = "Набор символов Win";
char *cKoi = "Набор противоположных символов";
for (int a = 0; a < strlen(cWin); a++)
if (sym == cKoi[a])sym = cWin[a];

return sym;
}

И перед каждым выводом к примеру это делать вполне приемлемо

Ибо не видел консолей которые романы или дисертации
в окне выдавали

Например для того же указания локации с русскими именами, этого вполне достаточно

З.Ы. - Сори если не втему, я просто полностью не читал все сообщения, тока то YackoN, что писал

.Земляк. · Отправлено: **21:39, 16-12-2009** | #67

Код:

char* Decode_DOS_to_Win(char * str)
 {
     unsigned char *cstr=str; // "unsigned" - чтоб избежать предупреждений комп-ра
     for(; *cstr; cstr++)
     {
         if(*cstr<128) continue; // не фиг топтаться дальше, если не нужно конвертить!
         if(*cstr>=128 && *cstr<=175)
             *cstr+=64;
         else if(*cstr>=224 && *cstr<=239)
             *cstr+=16;
         else if(*cstr==252) // №
             *cstr=185;
         else if(*cstr==240) // Ё, Е с двумя точками - Йо
             *cstr=168; 
         else if(*cstr==241) //  Ё, е с двумя точками - йо
             *cstr=184;
         else if(*cstr==242) // Є, украинское Йе
             *cstr=170;
         else if(*cstr==243) // є, украинское йе
             *cstr=186;
         else if(*cstr==244) // Ї, украинское Йи
             *cstr=175;
         else if(*cstr==245) // ї, украинское йи
             *cstr=191;
         else if(*cstr==246) // Ў, беларусская У с хвостиком вверху - незнаю, как читается
             *cstr=161;
         else if(*cstr==247) // ў, беларусская У с хвостиком вверху - незнаю, как читается
             *cstr=162;
         else if(*cstr==248) // знак градуса
             *cstr=176;
         else if(*cstr==250) // маленькая центровая точка
             *cstr=183;
         else
             *cstr='?'; // некий символ, которым заменять несуществующие в CP1251
     }
     return str;
 }
//----------------------------------------------------
char* Decode_Win_to_DOS(char * str)
 {
     unsigned char *cstr=str;
     for(;*cstr;cstr++)
     {
         if(*cstr<128) continue; // не фиг топтаться дальше, если не нужно конвертить!
         if(*cstr>=240)
             *cstr-=16;
         else if(*cstr>=192)
             *cstr-=64;
         else if(*cstr==185) // №
             *cstr=252;
         else if(*cstr==168) // Ё, Е с двумя точками - Йо
             *cstr=240;
         else if(*cstr==184) //  Ё, е с двумя точками - йо
             *cstr=241;
         else if(*cstr==170) // Є, украинское Йе
             *cstr=242;
         else if(*cstr==186) // є, украинское йе
             *cstr=243;
         else if(*cstr==175) // Ї, украинское Йи
             *cstr=244;
         else if(*cstr==191) // ї, украинское йи
             *cstr=245;
         else if(*cstr==178) // I, украинское И
             *cstr=73;            // в английскую, т.к. в ДОСе нет
         else if(*cstr==179) // i, украинское и
             *cstr=105;         // в английскую, т.к. в ДОСе нет
         else if(*cstr==161) // Ў, беларусская У с хвостиком вверху - незнаю, как читается
             *cstr=246;
         else if(*cstr==162) // ў, беларусская У с хвостиком вверху - незнаю, как читается
             *cstr=247;
         else if(*cstr==176) // знак градуса
             *cstr=248;
         else if(*cstr==183) // маленькая центровая точка
             *cstr=250;
         else
             *cstr='?'; // некий символ, которым заменять несуществующие в CP1251
     }
     return str;
 }

ganselo · Отправлено: **12:01, 17-12-2009** | #68

.Земляк. , зачем это вообще нужно, ведь есть уже готовые функции (правда только в win): CharToOem(...), OemToChar(...).

prospero_ua · Отправлено: **19:15, 17-12-2009** | #69

Ну вы блин даёте!
Решение, которое точно работает в MSVS:

Код:

setlocale( LC_ALL, ".1251" );
char szText[] = "Hello! Привет!";
std::cout << (szText) << std::endl;

NYX · Отправлено: **16:42, 21-12-2009** | #70

(!!!) Видим 866, имеем 1251 (!!!) + возможность вводить пароли ***** символами

(!!!)
Значит к какому результу я притаранился

Для начала в теле функции main() прописываем APIшные строки:

SetConsoleCP(1251);
SetConsoleOutputCP(1251);

Затем, у меня стоит своя собственная приблуда, которая ограничивает количество вводимых символо при помощи label: goto label; в теле
которого я тупо повесил char cWord = getch(); и если cWord != VK_RETURN, пишем в массив СИМВОЛ в кодировке 1251 а на экран выводим в кодировке 866 (OEM);
Вот листинг

Код:

bool GetArg(char cString[], int iSize, bool Masked)
{

int iLength = 0;
char cWord = 0;
enter_word:
cWord = getch();
if (cWord == VK_TAB)cWord = 13;
if (cWord == 22) // Paste From Clipboard
    {
    if ((iLength+Clipboard()->AsText.Length()) <= iSize)
        {
        for (int newindex = iLength; newindex < (iLength + Clipboard()->AsText.Length()); newindex++)
        cString[newindex] = Clipboard()->AsText[newindex-iLength+1];
        iLength += Clipboard()->AsText.Length();
        cout << Clipboard()->AsText.c_str();
        }
    goto enter_word;
    }

if (cWord == VK_ESCAPE)SendMessage(FindWindow("ConsoleWindowClass", NULL), WM_CLOSE, 0, 0);
if (cWord != VK_RETURN)
    {
    if (cWord != VK_BACK)
        {
        if (iLength < iSize)
            {
            cString[iLength] = cWord;
            ToWin(&cWord);
            if (Masked)
            cout << '*';
            else
            cout << cWord;
            iLength++;
            }
        }
        else
        {
        if (iLength > 0)
            {
            cout << "\b \b";
            iLength--;
            cString[iLength] = 0;
            }
        }
    goto enter_word;
    }
    else
    {
    if (strlen(cString) > (unsigned)iSize){cout << " -- Buffer oveflow (press key)"; return 0;}
    iLength = 0;
    if (strlen(cString) > 0)
        {
        return 1;
        }
    goto enter_word;
    }
}

// Кстати незаменимая штукенция на тот случай если в консоли надо ввест пароль :) последним аргументом это регулируется :)

в листинге есть вызов некой ToWin(&cWord); которая и транслирует мне 1251 в 866

делает она это так:

Код:

void ToWin(char *symbol) 
{
for (unsigned int CPIndex = 0; CPIndex < strlen(Win); CPIndex++)
if (*symbol == Oem[CPIndex])*symbol = Win[CPIndex];
}

перед стартом проги делается это: // объявляется перед стартом потока main(); тобешь ГЛОБАЛЬНО
char Win[67];
char *Oem = "ÀÁÂÃÄÅ¨ÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäå¸æçèéêëìíîïðñòóôõö÷øùúûüýþÿ";
CharToOem("ÀÁÂÃÄÅ¨ÆÇÈÊÉËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäå¸æçèéêëìíîïðñòóôõö÷øùúûüýþÿ", Win); // Лень переписывать (в массивы загоняются А-Я-а-я)

ФФух кажысь выложил идейку

Да и уж извините что офтопю, просто на радостях:
Написал штучку зугружающую картинку в консоль

вот она:

Код:

for(long y = 0; y < 120; ++y)
    {
    for(long x = 0; x < 400; ++x)
		{
        SetPixel(dc, x, y, logo_img[y * 400 + x]);
  		}
    }
Sleep(1000);
for(long y = 0; y < 120; ++y)
    {
    for(long x = 0; x < 400; ++x)
		{
        SetPixel(dc, x, y, 0);
  		}
    }

unsigned long logo_img[144056] = {0,0,0 ... }; // это массив который я собрал из имеющегося логотипа :) сделал это для того что бы не было зависимости вылетов в тех ситуациях, когда отсутствует логотип. Написал программку, которая делает так:

#include <assert.h>

HBITMAP hBmp = (HBITMAP)LoadImage(GetModuleHandle(0), "logo.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
BITMAP bmpInfo = {};
::GetObject(hBmp, sizeof(BITMAP), &bmpInfo);
assert(bmpInfo.bmBitsPixel / 8 == sizeof(COLORREF));
LONG nCount = bmpInfo.bmWidth * bmpInfo.bmHeight;
COLORREF* pBits = new COLORREF[nCount];
GetBitmapBits(hBmp, nCount * sizeof(COLORREF), pBits);

затем этот самый pBits[] посимвольно вывожу в файл, который формируется таким образом:
сначала добавляю строки
#ifndef MYLOGO_H
#define MYLOGO_H
unsigned long logo_img[размер pBits в байтах] = { ... далее циклом вставляю pBits[x] << ","; (!!!) // Самое главное каждые 10 выводов в файл, надо вставлять '\n' ибо компилятор будет
материться если в строке будет дофига символов

Да и логотип такого размера будет туговато грузиться на машинках от 900 Мгц

так что лучше делать голотипчик размером не более 5000 байт, в таком случае он на стареньких компах
будет более менее грузиться (например проверил на Asus Eee 701 - 10кратное обновление картинки заняло около 20 сек, в то время как на 2х-яйцовом камушке эта дело занимало меньше секунды))))