¿Buffer de entrada en modo binario?

[aguml]

Pues estoy liado con caracteres que si los leo o escribo en un archivo tanto en C como en C++ al hacerlo en modo binario no tengo problemas pero al hacerlo en modo texto plano no va bien y guarda y lee cosas raras. El caso es que con los archivos se solucionó abriéndoles en binario pero ahora quiero hacer lo mismo con el buffer de entrada y me gustaría poder hacerlo tanto en C como en C++.
He estado buscando información y he visto que con stringstream y read podría leer en binario del buffer en C++ pero claro, estoy obligado a capturar un número de bytes que se le indica a read y mi intención es hacer como con cin o scanf que al pulsar intro termina la captura. ¿alguien sabría como lograr lo que deseo?

[eferion]

prueba con wstring, wcout y wcin en vez de con string, cout y cin.

El problema es el comentado en otras ocasiones... la tabla ASCII incorpora únicamente el juego de caracteres inglés. Para gestionar alfabetos diferentes sueles necesitar más de un byte por caracter... para eso existe wstring. Un pequeño inconveniente tanto de string como de wstring es que no hay conversiones directas a unicode, pero eso puede no ser un problema para tí.

Un saludo.

[aguml]

No veo la manera de hacerlo. He estado intentando usar unsigned char*, wstring, freopen para abrir el buffer de entrada en modo binario y luego leer con read en binario,... y nada.
El codigo lo tengo ahora mismo asi:
Parte 1:

Código C++:

//---------------------------------------------------------------------------
 
#include <iostream>
#include <cstdlib>
#include <fstream>
 
string CesarEncriptText(string entrada, int desplazamiento);
string CesarDecriptText(string entrada, int desplazamiento);
int CesarEncriptFile(char *nameFileIn, int desplazamiento, char *nameFileOut);
int CesarDecriptFile(char *nameFileIn, int desplazamiento, char *nameFileOut);
void OpcionEncriptFile();
void OpcionDecriptFile();
 
string Letras="ABCDEFGHIJKLMNÑOPQRSTUVWXYZabcdefghijklmnñopqrstuvwxyz1234567890ÁÉÍÓÚáéíóúÜü \".,:;-+*/=\\_<>¡!¿?|@#$%&()[]{}\'^ºª";
//---------------------------------------------------------------------------
 
int main(int argc, char* argv[])
{
   char aux[1024];
   string desencriptado;
   string encriptado;
   int op,salir=0,volver=0,rotacion;
 
   do{
      cout << "Cifrado/Descifrado Cesar" << endl;
      cout << "------------------------" << endl;
      cout << "1.Texto" << endl;
      cout << "2.Archivo" << endl;
      cout << "3.Salir" << endl;
      cout << "Elige una opcion: ";
      cin >> op;
      cin.clear();
 
      // Ignore to the end of file
      //cin.ignore(std::numeric_limits<std::streamsize>::max());
 
      // Ignore to the end of line
      cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
      switch(op){
         case 1:
            do{
               system("CLS");
               cout << "Cifrado/Descifrado de texto con cifrado Cesar" << endl;
               cout << "---------------------------------------------" << endl;
               cout << "1.Encriptar texto" << endl;
               cout << "2.Desencriptar texto" << endl;
               cout << "3.Volver" << endl;
               cout << "Elige una opcion: ";
               cin >> op;
               cin.clear();
 
               // Ignore to the end of line
               cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
               switch(op){
                  case 1:
                     cout << "Introduce el texto a encriptar: ";
                     cin.getline(aux,1023,'\n');
                     desencriptado=aux;
                     cout << "Introduce el desplazamiento: ";
                     cin >> rotacion;
 
                     // Ignore to the end of line
                     cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
                     if((encriptado=CesarEncriptText(desencriptado,rotacion)) != ""){
                        cout << "Encriptado finalizado satisfactoriamente" << endl;
                        cout << "Encriptado queda: " << encriptado << endl;
                     }else{
                        cout << "Caracteres no validos en el texto a encriptar" << endl;
                     }
                     cin.get();
                     break;
                  case 2:
                     cout << "Introduce el texto a desencriptar: ";
                     cin.getline(aux,1023,'\n');
                     encriptado=aux;
                     cout << "Introduce el desplazamiento: ";
                     cin >> rotacion;
 
                     // Ignore to the end of line
                     cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
                     if((desencriptado=CesarDecriptText(encriptado,rotacion)) != ""){
                        cout << "Encriptado finalizado satisfactoriamente" << endl;
                        cout << "Desencriptado queda: " << desencriptado << endl;
                     }else{
                        cout << "Caracteres no validos en el texto a desencriptar" << endl;
                     }
                     cin.get();
                     break;
                  case 3:
                     volver=1;
                     break;
                  default:
                     cout << "Opcion no valida. Pulsa intro y vuelve a intentarlo" << endl;
                     cin.get();
               }
            }while(volver==0);
            cin.get();
            system("CLS");
            break;
 
         case 2:
            do{
               system("CLS");
               cout << "Cifrado/Descifrado de archivo con cifrado Cesar" << endl;
               cout << "-----------------------------------------------" << endl;
               cout << "1.Encriptar archivo" << endl;
               cout << "2.Desencriptar archivo" << endl;
               cout << "3.Volver" << endl;
               cout << "Elige una opcion: ";
               cin >> op;
               cin.clear();
 
               // Ignore to the end of line
               cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
               switch(op){
                  case 1:
                     OpcionEncriptFile();
                     cin.get();
                     break;
                  case 2:
                     OpcionDecriptFile();
                     cin.get();
                     break;
                  case 3:
                     volver=1;
                     break;
                  default:
                     cout << "Opcion no valida. Pulsa intro y vuelve a intentarlo" << endl;
                     cin.get();
               }
            }while(volver==0);
            system("CLS");
            break;
 
         case 3:
            salir=1;
            break;
 
         default:
            cout << "Opcion no valida" << endl;
      }
   }while(salir == 0);
   return 0;
}
 

[aguml]

Parte 2:

Código C++:

void OpcionEncriptFile()
{
   char origen[1024];
   char salida[1024];
   int rotacion;
 
   cout << "Introduce el path del archivo que contiene el texto a encriptar: ";
   cin.getline(origen,1023,'\n');
   cout << "Introduce el path del archivo de salida: ";
   cin.getline(salida,1023,'\n');
   cout << "Introduce el desplazamiento: ";
   cin >> rotacion;
 
   // Ignore to the end of line
   cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
   switch(CesarEncriptFile(origen,rotacion,salida)){
      case 0:
         cout << "Cifrado satisfactorio" << endl;
         break;
      case -1:
         cout << "Se encontraron caracteres no validos" << endl;
         break;
      case -2:
         cout << "No se pudo abrir el archivo de origen" << endl;
         break;
      case -3:
         cout << "No se pudo abrir el archivo de destino" << endl;
         break;
   }
}
 
void OpcionDecriptFile()
{
   char origen[1024];
   char salida[1024];
   int rotacion;
 
   cout << "Introduce el path del archivo que contiene el texto a desencriptar: ";
   cin.getline(origen,1023,'\n');
   cout << "Introduce el path del archivo de salida: ";
   cin.getline(salida,1023,'\n');
   cout << "Introduce el desplazamiento: ";
   cin >> rotacion;
 
   // Ignore to the end of line
   cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
   switch(CesarDecriptFile(origen,rotacion,salida)){
      case 0:
         cout << "Descifrado satisfactorio" << endl;
         break;
      case -1:
         cout << "Se encontraron caracteres no validos" << endl;
         break;
      case -2:
         cout << "No se pudo abrir el archivo de origen" << endl;
         break;
      case -3:
         cout << "No se pudo abrir el archivo de destino" << endl;
         break;
   }
}
 
int CesarEncriptFile(char *nameFileIn, int desplazamiento, char *nameFileOut)
{
   string final;
   ifstream origen;
   ofstream salida;
   char *cadena;
   int i,posInicial,posFinal;
   int retval=0;
 
   origen.open(nameFileIn,ios::binary);
 
   if(origen.good()){
      origen.seekg(0,ios::end);
      int length = origen.tellg();
      origen.seekg(0,ios::beg);
      cadena = new char[length+1];
 
      salida.open(nameFileOut,ios::binary | ios::trunc);
 
      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
 
         for(i=0;i<length;i++){
            posInicial = Letras.find(cadena[i]);
            if(posInicial < 0){
               retval=-1;
               break;
            }
            posFinal = (Letras.length() + posInicial + desplazamiento) % Letras.length();
            final.append(Letras, posFinal, 1);
         }
         salida.write(final.c_str(),length);
         salida.close();
      }else{
         retval=-3;
      }
      delete(cadena);
      origen.close();
   }else{
      retval=-2;
   }
   return retval;
}
//---------------------------------------------------------------------------
 
int CesarDecriptFile(char *nameFileIn, int desplazamiento, char *nameFileOut)
{
   string final;
   ifstream origen;
   ofstream salida;
   char *cadena;
   int i,posInicial,posFinal;
   int retval=0;
 
   origen.open(nameFileIn,ios::binary);
 
   if(origen.good()){
      origen.seekg(0,ios::end);
      int length = origen.tellg();
      origen.seekg(0,ios::beg);
      cadena = new char[length+1];
 
      salida.open(nameFileOut,ios::binary | ios::trunc);
 
      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
 
         for(i=0;i<length;i++){
            posInicial = Letras.find(cadena[i]);
            if(posInicial < 0){
               retval=-1;
               break;
            }
            posFinal = (Letras.length() + posInicial - desplazamiento) % Letras.length();
            final.append(Letras, posFinal, 1);
         }
         salida.write(final.c_str(),length);
         salida.close();
      }else{
         retval=-3;
      }
      delete(cadena);
      origen.close();
   }else{
      retval=-2;
   }
   return retval;
}
//---------------------------------------------------------------------------
 
string CesarEncriptText(string texto, int desplazamiento)
{
   int i,posInicial,posFinal;
   string final;
 
   for(i=0;i<texto.length();i++){
      posInicial = Letras.find(texto.at(i));
      if(posInicial < 0){
         final="";
         break;
      }
      posFinal = (Letras.length() + posInicial + desplazamiento) % Letras.length();
      final.append(Letras, posFinal, 1);
   }
   return final;
}
//---------------------------------------------------------------------------
 
string CesarDecriptText(string texto, int desplazamiento)
{
   int i,posInicial,posFinal;
   string final;
 
   for(i=0;i<texto.length();i++){
      posInicial = Letras.find(texto.at(i));
      if(posInicial < 0){
         final="";
         break;
      }
      posFinal = (Letras.length() + posInicial - desplazamiento) % Letras.length();
      final.append(Letras, posFinal, 1);
   }
   return final;
}
//---------------------------------------------------------------------------
 

La parte que cifra y descifra archivos va perfecta pero el problema lo tengo con el buffer de entrada que en el momento que meto un caracter que no es de los estandar se carga la jugada jejeje.

Tambien hice esta prueba y no funcionó porque simplemente no guarda nada ni en waux:

Código C++:

cout << "wstring: ";
   wstring wstr;
   wchar_t waux[1024];
   cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   wcin.getline(waux,1024,'\n');
   wstr = waux;
 

[eferion]

Utilizar caracteres fuera del estándar ASCII suele ser problemático tanto en C como en C++.

En estos casos lo más recomendado es utilizar alguna librería especializada en la gestión de caracteres no ASCII.

Qt por ejemplo tiene un soporte buenísimo para cualquier alfabeto, puede ser una solución a tu problema.

[aguml]

Me parece increíble que ni el estándar de C ni el de C++ estén preparados para algo tan básico como capturar del teclado en binario. Los caracteres estándar llegan hasta 125 y el resto no simplemente porque un char no da más pero un uchar si que puede ya que no hay negativos así que no entiendo porque el código que puse no captura por ejemplo la Ñ que si que esta entre los 255 caracteres.

[eferion]

Iniciado por aguml

Me parece increíble que ni el estándar de C ni el de C++ estén preparados para algo tan básico como capturar del teclado en binario. Los caracteres estándar llegan hasta 125 y el resto no simplemente porque un char no da más pero un uchar si que puede ya que no hay negativos así que no entiendo porque el código que puse no captura por ejemplo la Ñ que si que esta entre los 255 caracteres.

El estándar de C++ deja mucho que desear en cosas tan básicas como la gestión de la consola o las cadenas de caracteres... los últimos dos estándares C++11 y C++14 han corregido algunas lagunas muy serias del lenguaje, como el soporte multihilo de forma estándar, pero aún le queda mucho camino por recorrer.

Uno de los mayores problemas es conseguir que los nuevos estándares no afecten a la compilación de código realizado con versiones anteriores... no se, seguramente esto se acabe corrigiendo, pero desde luego no va a ser mañana :)

[jorgegl]

Iniciado por aguml

Me parece increíble que ni el estándar de C ni el de C++ estén preparados para algo tan básico como capturar del teclado en binario. Los caracteres estándar llegan hasta 125 y el resto no simplemente porque un char no da más pero un uchar si que puede ya que no hay negativos así que no entiendo porque el código que puse no captura por ejemplo la Ñ que si que esta entre los 255 caracteres.

Que quieres decir por capturar del teclado en binario?

Que entiendes por caracteres estandar?

En realidad si puedes almacenar un caracter con codigo ascii superior a 127 en una variable de tipo char. Por ejemplo la ñ que vale 150. La distincion entre con signo o sin signo solo te afecta para cuestiones aritmeticas. A ti te da igual, al fin y al cabo las dos son un espacio de memoria de 1 byte.

Ese no es el problema, y de hecho para imprimir por pantalla una ñ no te hace falta ni siquiera un wide-character, y mucho menos tirar de unicode. Mira a ver si esto te funciona e imprime una "ñ" despues de "abc". Luego prueba a comentar la linea del "setlocale" y mira a ver si ya no eres capaz de imprimirla. Si es asi, prueba a meter la linea del "setlocale" en tu programa, al principio, y mira a ver si funciona.

Código:

#include <iostream>
#include <clocale>

int main()
{
char a[] = "abcñ";
std::setlocale(LC_ALL, "");
std::cout << a << std::endl;

return 0;
}

[eferion]

Iniciado por jorgegl

Ese no es el problema, y de hecho para imprimir por pantalla una ñ no te hace falta ni siquiera un wide-character, y mucho menos tirar de unicode. Mira a ver si esto te funciona e imprime una "ñ" despues de "abc". Luego prueba a comentar la linea del "setlocale" y mira a ver si ya no eres capaz de imprimirla. Si es asi, prueba a meter la linea del "setlocale" en tu programa, al principio, y mira a ver si funciona.

El problema que tiene C++ es que no ha adoptado un mecanismo uniforme para gestionar strings en lenguajes diferentes al inglés. Quizás para entrada/salida funcione tu solución, pero si luego intentas manipular los caracteres para, por ejemplo, realizar transformaciones, la 'ñ', que puede perfectamente acabar ocupando 2 bytes en su codificación, te encuentras con que tienes que lidiar manualmente con estas circunstancias cuando no debería ser así.

Desde mi punto de vista cada item individual de un string debería corresponder a un carácter, independientemente de que dicho carácter ocupe 1 byte o 4 bytes, y en este punto el estándar de C++ falla irremediablemente.

[aguml]

Funciona a medias. Si imprime caracteres como la ñ pero el problema principal es que al comparar los caracteres introducidos con los de una string, aun introduciendo lo mismo no funciona. Si se mira el valor que hay en lo que introducimos y miramos el valor almacenado en la cadena en la que buscamos ese valor veremos que no es el mismo. Hice este pequeño codigo para que veas la diferencia y a ver si pueden ayudarme:

Código C++:

#include <iostream>
#include <clocale>
#include <cstring>
 
using namespace std;
 
int main()
{
   char a[] = "ñ";
   char b[2]={0};
   bool encontrada=false;
 
   setlocale(LC_ALL, "");
   cout << "Introduce el caracter a buscar en 'a': ";
   cin.getline(b,2,'\n');
   for(int i=0;i<strlen(a);i++){
      if(a[i]==b[0]){
         cout << "encontrada en la cadena " << a << " en la posicion: " << i << endl;
         encontrada=true;
      }
   }
   if(!encontrada)
      cout << "no encontrada en la cadena " << a << endl;
 
   cout << "Valor de a: " << (char)a[0] << endl;
   cout << "Valor de b: " << (char)b[0] << endl;
   return 0;
}
 

[eferion]

Iniciado por aguml

el problema principal es que al comparar los caracteres introducidos con los de una string, aun introduciendo lo mismo no funciona.

Iniciado por eferion

... pero si luego intentas manipular los caracteres para, por ejemplo, realizar transformaciones, la 'ñ', que puede perfectamente acabar ocupando 2 bytes en su codificación, te encuentras con que tienes que lidiar manualmente con estas circunstancias cuando no debería ser así.

Yo te recomendaría usar alguna librería que trabaje con unicode o usar Qt.

[lareto]

Hola; creo que hay una confusión aquí. El C++ no tiene nada que ver con ninguna consola; esas son cosas de tu sistema operativo.
Asumo que usas Windows.

En tu código, voy a cambiar un par de líneas que usas para mostrar las dos cadenas a y b, por estas otras:

Código:

cout << "Valor de a: " << (int)(unsigned char)a[0] << endl;
cout << "Valor de b: " << (int)(unsigned char)b[0] << endl;

Así tendría que mostrar el valor decimal de la primera "ñ" que has escrito para a, y de las segunda "ñ", que has ingresado por teclado.

Se debería mostrar:

Código:

Valor de a: 241
Valor de b: 164

Donde el primero de esos valores fue generado por el editor de texto que usaste para escribir el código y luego compilarlo y el segundo fue generado por tu consola. Pero la consola de Windows usa el viejo juego de caracteres IBM, anterior al ASCII de 127 caracteres (y anterior, naturalmente, al ASCII extendido de 256, y ni hablar de Unicode). Y en ese juego de caracteres, la "ñ" tiene el valor decimal 164. Entonces, la primera "ñ" (decimal 241) es correcta, es la que escribió tu editor de texto como sabe hacerlo, y la segunda "ñ" (decimal 164) también es correcta, es la que escribió la consola con el juego de caracteres que usa hace 30 años (puedes ver https://en.wikipedia.org/wiki/Code_page_437)

Si pones esta línea (https://msdn.microsoft.com/en-us/lib...=vs.85).aspx):

Código:

SetConsoleCP(GetACP());

antes de usar la consola (necesita #include "Windows.h"), pondrás el input code page de la consola en armonía con el ANSI code page que esté activo en tu Windows.

Bueno, como ves, nada de todo esto tiene que ver con el C++, para el que ni siquiera existen los conceptos de "consola" ni de "teclado", figúrate. Y por favor, deja eso de "capturar del teclado en binario", que sólo tú sabrás qué has querido decir, y esas quejas sobre el lenguaje, al menos espera a enterarte un poco de qué va... :)

[aguml]

Ok amigo, es lo que pasa cuando uno habla desde el desconocimiento, que puede soltar burradas para los oidos de los que realmente saben jejeje.
Ahora si que me funciona esa parte pero ahora tengo otro problema. Con mi codigo, si le digo que quiero descifrar la letra 'ñ' con un desplazamiento de 5 me tendria que mostrar la 'ñ' pero sin embargo me muestra el simbolo matematico '±' incluso teniendo la linea setlocale(LC_ALL, ""); que se supone que es para que me muestre los caracteres especiales ¿no? Con lo que he leido de tu contestacion entiendo que con SetConsoleCP(GetACP()); cambio la pagina de codificacion de la consola pero eso hace que el caracter 'ñ' valga 241 mientras que si miro la tabla ascii extendido veo que vale 145 y que el 241 es realmente el que me está mostrando. ¿tengo que cambiar tambien algo de la salida de consola para que me muestre los caracteres correctamente? ¿puedes ayudarme con esto ultimo?
Edito:
Lo he solucionado esto último después de buscar mucho ya que al usar SerConsoleOutputCP (GetACP ()); me pasaba que al dar a alguna tecla especial como por ejemplo la Ñ no me imprimía esta en consola y encontré este enlace: http://es.comp.lenguajes.c.narkive.c...mostrando-enes
Y con esa ayuda me cree esta funcion:

Código C++:

string StringToOem (string cadena)
{
   char *aux=new (nothrow) char [cadena.length ()];
   if (aux != NULL){
      CharToOem (cadena.c_str (),aux);
      cadena=aux;
      delete aux;
   }else {
      cadena="";
   }
   return cadena;
}
 

Luego de obtener la cadena cifrada hago:

Código C++:

encriptada=StringToOem (encriptada);
 

Y ya la muestro y se ve perfecta.
He probado también a cambiar la fuente de la consola y también funcionaba pero quería saber que opción es más limpia y por cual optarIan.