Кирилица в консоли

[Alan85]

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

[Drongo]

Drongo, А твой пример при компиляции ссылается на:
error C2440: 'initializing' : cannot convert from 'char *' to 'unsigned char *' »Ну, наверное тип передаваемого параметра сменить попробовать в unsigned char
Вместо
...
// Функция перекодировки в кирилицу
char* rus(char* st)
{
...на такой
...
// Функция перекодировки в кирилицу
char* rus(unsigned char* st)
{
...

[hda0]

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

[ganselo]

Вот вариант своего класса для ввода/вывода на кириллице
(для 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]

Всем привет!
Работая с функцией isdigit() (данная функция определяет - является ли символ числом), необходимо было проверять является ли её потенциальный аргументы латинским символом. При взятии от кириллического происходит крушение программы. Это подвело к тому, что данная функция и не нужна, раз идёт проверка символов то уже проще самостоятельно определить является ли символ числом.
Для корректной работы isdigit() с массивами символов, где может быть кириллица, нужно определять массив символов как unsigned char, а не просто char, по этому решения сабжа предполагает использования в двух вариантах.
Итак, имеет MS-DOS кодовую страницу 866 (Code Page 866 MS-DOS) (http://msdn.microsoft.com/en-us/library/cc195074.aspx) применяемую в консольных приложениях для Виндовс.
Её всегда можно подсмотреть таким вот образом
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, не учтены в коде данной программы.

В Windows 7 добиться отображения кириллицы в консоли с помощью данного способа не получилось. Вместо кириллицы код прогоняющий таблицу символов отобразил невнятные символы, греческий алфавит.
Юникод вариант, расписанный здесь unicode и printf (http://programmersforum.ru/showthread.php?t=22669) ,так же не прошёл.

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

[NYX]

Ну вы ребят даете, громоздкие коды такие :) Сори за остроумность, на на мой взгляд загон из 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, что писал :)

[.Земляк.]

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]

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

[prospero_ua]

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

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

[NYX]

(!!!) Видим 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х-яйцовом камушке эта дело занимало меньше секунды))))

[Lisiy_egik]

вот этот файл при подключении позволяет выводить кириллицей.

подключаешь, #include "rus8.h" B main и rus8(); в самом теле main

сам хэдер (http://depositfiles.com/files/jjs9hg8kg)

/* RUS8.H
Универсальный включаемый файл для русского ВЫВОДА консольного
приложения ( MVS.NET2005 )

!!! ВАЖНО !!!
1. Подключается только в файл с функцией main( )
2. В самом начале main( ) вызвать функцию rus( )
main( )
{
rus( );
...
}
!!!!!!!!!!!!!

Санкт-Петербургский Государственный Политехнический Университет
Факультет Технической Кибернетики
Кафедра Автоматики и вычислительной техники

Сидорина Т.Л.
*/

#ifndef _RUS_H
#define _RUS_H

#include <locale.h>

inline void rus( void )
{
setlocale( LC_CTYPE, ".1251" );
setlocale( LC_MONETARY, ".1251" );

return;
}

#endif

[ganselo]

при подключении позволяет выводить кириллицей »
А в моей среде разработки не работает (среда - Code Blocks, компилятор mingw). А в MSVS 2005 работает. По умолчанию в редакторе стоит кодировка Win1251 и файл сохраняется в той же кодировке.

[Redisych]

Такая же петрушка, Code Blocks & mingw не дают кириллицу.
Я вот всё думаю, если в редакторе 1251 сменить на 866, чем это грозит? Потом в другом месте перекорёжит?

Ещё нарыл решение.
в заголовок вставляем
#include<clocale>
в main
setlocale(LC_CTYPE, "");

Тоже, почему-то, не работает.


НАШЁЛ!!!
В main прописываем:
system("chcp 1251 > nul");

[nurfet]

#include <windows.h>

SetConsoleCP(1251);
SetConsoleOutputCP(1251);

Для ввода и отображении кирилицы

[Drongo]

#include <windows.h>
SetConsoleCP(1251);
SetConsoleOutputCP(1251); »Этот способ вроде для визуалки подходит?

[котвася]

//*******************************************************

#include <iostream>
#include <locale.h>

//*******************************************************

int main()
{
//setlocale(LC_ALL,".1251");
std::system("@echo привет");
std::cout<<std::endl;
std::system("@pause");
return 0;
}


можно вот еще как.

[nurfet]

#<windows.h>

int main()
{
system("chcp 1251 > nul");

И в свойствах консольного окна на вкладке шрифт выбрать Lucida Console

[Redisych]

После долгого перерыва занялся. Свежая версия CodeBlocks 10.05 с набортным компилятором GCC.
М-дя... Ни один из способов не работает.

---upd 12/07/10
Сегодня работает. Ничего не понимаю в этом полтергейсте.

[Glareone]

#include <windows.h>
SetConsoleCP(1251);
SetConsoleOutputCP(1251); »

И в свойствах консольного окна на вкладке шрифт выбрать Lucida Console »

#<windows.h>
int main()
{
system("chcp 1251 > nul"); »

оба способа прекрасно работают.

[soft.creator]

Предлагаю еще один вариант: ссылка (http://softcreator.livejournal.com/594.html)
Может, кому и понравится.