[SOLUCIONADO] Generar archivo con codificacion Windows-1252

[dehm]

Hola de nuevo:

Pues resulta que sigo enredando con lo mio, y ahora toca hacer un exportador para generar unos ficheros de intercambio en texto plano.

Leyendo las especificaciones que ha de llevar, dice que la codificación será :
el juego de caracteres a emplear es el definido para D.O.S., cuyos identificadores serán 850 ó 437, o es el definido para Windows, cuyo identificador será ANSI

Así que genero el fichero en texto plano, voy a abrirlo con una aplicación de verdad que hace uso de este fichero, y me da errores.

Se me ocurre, ya que es texto plano, abrirlo con Gedit (estoy en Linux) y desde ahí cambiar la codificación a Windows-1252 (occidental). Vuelvo entonces a abrir el fichero y ya funciona.

El propio Gedit ya me está diciendo que mi fichero original se codifica en UTF-8


Así que la pregunta es....¿como hacerlo directamente en C++?
Creo que en Qt hay más facilidades para lidiar con la codificación, pero todavía "no he llegado" y además me gustaría saber cómo resolver esto en C++ sin Qt (y en Linux)

Gracias!

[lareto]

Así que genero el fichero en texto plano, voy a abrirlo con una aplicación de verdad que hace uso de este fichero, y me da errores.

¿Qué errores?

Así que la pregunta es....¿como hacerlo directamente en C++?

¿Cómo lo estás haciendo ahora?

[dehm]

Hola, simplemente no me lee toda la información o me la lee mal.

Ahora mismo lo estoy haciendo al modo clásico:
Mas o menos: (esto es como escribo uno de los tipos de información, hay mas, pero en esencia son del estilo)

Código C++:

void AbrirGuardarBC3::EscribirRegistroT(const pNodo concepto, std::ofstream &ofs)
{
    std::string registroT="~T|";
    registroT.append(concepto->datonodo.LeeCodigo());
    registroT.append("|");
    registroT.append(concepto->datonodo.LeeTexto());
    registroT.append("|");
    ofs.write(registroT.c_str(),registroT.size());
    ofs.write(&NuevaLinea,1);
    ofs.write(&RetornoCarro,1);
}
 

Al final obtengo un fichero de texto plano en codificación UTF-8, que no cumple el estandar (yo pensé que era una chorrada lo de la codificación, pero ha resultado que efectivamente estos ficheros han de estar codificados en ANSI o Windows-1252). Las aplicaciones que existen son todas "muy windows", aunque pienso que el tema de la codificación es por compatibilidad con aplicaciones algo arcaicas.

Saludos y gracias!

[lareto]

Si el archivo lo estás generando en Windows, debe estar en el code page 1252, que no es UTF-8, sino que los primeros 256 code points de UTF-8 coinciden con el ASCII extendido del CP 1252.

Si el ofstream está abierto en modo texto (por defecto es así), la diferencia entre Windows y Linux es sólo la forma de escribir un salto de línea (\r\n para Windows, \n para linux), pero el gedit debería saltarse esa diferencia sin quejas.

Si el archivo que escribes en un sistema operativo se ve distinto en el otro, es probable que haya algún error al generarlo, no creo que sea por el code page que usa windows por defecto.

[lareto]

Ah, no reparé en

ofs.write(&NuevaLinea,1);
ofs.write(&RetornoCarro,1);

Entonces, estás abriendo el oftream en modo "binario", ¿verdad? Entonces la secuencia debería ser al revés:
ofs.write(&RetornoCarro,1); // \r
ofs.write(&NuevaLinea,1); // \n

Pero, para escribir texto, me parece que es mejor abrir el ofstream en modo texto, y usar <<.

[dehm]

Iniciado por lareto

Ah, no reparé en

Entonces, estás abriendo el oftream en modo "binario", ¿verdad? Entonces la secuencia debería ser al revés:
ofs.write(&RetornoCarro,1); // \r
ofs.write(&NuevaLinea,1); // \n

Pero, para escribir texto, me parece que es mejor abrir el ofstream en modo texto, y usar <<.

Bueno, primera equivocación por mi parte.
Por falta de atención, al hacer copia/pega de la función que guarda el archivo en modo binario no corregí eso y efectivamente me estaba escribiendo en binario.
Por otro lado, entre esa acertada observación y la posterior recomendación de escribir en el fichero mediante el operador << ya funciona.

Sólo he tenido que hacer otra pequeña modificación, y aprovecho para preguntarla:
Yo tenía definido los caracteres especiales así:

Código C++:

char NuevaLinea=10;
    char RetornoCarro=13;
    char FinDeArchivo=26;
 

Sin embargo esto también me estaba ocasionando problemas, y finalmente sólo he añadido "\r\n" (retorno de carro+nueva linea) para que por fin el fichero sea legible.

Entonces aprovecho para preguntar que diferencia hay entre una cosa y la otra.

Y finalmente te muestro el código que SI funciona

Código C++:

std::string registroT="~T|";
    registroT.append(concepto->datonodo.LeeCodigo());
    registroT.append("|");
    registroT.append(concepto->datonodo.LeeTexto());
    registroT.append("|");
    ofs<<registroT;
    ofs<<"\r\n";
 

(Por cierto, que gedit de esta forma me detecta la codificacion ISO-8859-15 y fin de línea Linux, pero el caso es que funciona)

Saludos y gracias!

[lareto]

Al final no me queda claro si estás abriendo el ofstream en modo "texto" o "binario".

// por las dudas... abierto en modo texto podría ser std::ofstream ofs ("test.txt");
// mientras que en modo binario: std::ofstream ofs ("test.txt", std::ofstream::binary);

Si lo estás abriendo en modo "texto" sólo deberías poner
ofs<<"\n"; porque Windows se va a encargar de convertir ese "\n" en el par "\r\n" (vaya gentileza); y si no, si pones los dos, al final en el archivo se va a escribir "\r\r\n" (¡gracias Windows!)

[dehm]

Hola:

Lo tenía mal, en modo binario, y ya lo he corregido, además de usar el operador << para mandar el contenido al ofstream.

Respecto a lo que me dices, al principio lo he puesto así "\n", pero seguía con los problemas a la hora de abrir el fichero, así que terminando cada línea con "\r\n" no me ha dado problema.
Hay que decir que realmente no estoy abriendo los ficheros en windows, sino bajo wine, aunque no creo que esto tenga que ver.
Saludos!

[lareto]

Supongo que has querido poner "\n" y no "|n", ¿verdad?


Hablando siempre de un ofstream abierto en modo texto, eh:
El código para escribir un salto de línea es el mismo en Windows y en Linux (o donde sea), es siempre

Código:

ofs << "\n";

La diferencia está en qué hace el compilador de Linux o el compilador de Windows con eso.

En linux va a tomar tu "\n" y lo va a escribir en el archivo tal cual como está, sin cambios.

En windows no, va a leer en tu código fuente que has puesto un "\n" y lo va a "completar" escribiendo la secuencia "\r\n".


Entonces, con exactamente el mismo código fuente:

Si el archivo lo has generado en linux, el final de cada línea va a ser un "\n".

Si por el contrario, al archivo lo has generado en windows, el final de cada línea va a ser el par "\r\n".

Y esa diferencia no depende de tí, depende de en qué sistema operativo se haya compilado ese fuente.

O sea: exactamente el mismo código fuente generará dos archivos de texto distintos. Así como suena. Si fuera necesario que los archivos generados sean idénticos, habrá que generarlo con un ofstream abierto en modo binario, y ahí, es uno el que decide si le va a poner un "\n" o el par "\r\n".