Mensajes

[método]

El método std::istream::getline está definido así:

Código (cpp) [Seleccionar] Expandir

istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

Es decir, el primer parámetro es de tipo cadena estilo C (es decir, tipo char*) y lo que tu le estás pasando es una cadena estilo C++, es decir, de tipo string. Para solucionar esto, tienes dos opciones: o bien declarar la cadena 'f' como char f[100], o bien usas la función std::getline, la cual está definida así:

Código (cpp) [Seleccionar] Expandir

istream& getline (istream& is, string& str);
istream& getline (istream& is, string& str, char delim);

1º aclaración: un valor arbitrario es aquel valor que tu decides, no es un valor aleatorio.
2º Aclaración: Vas a necesitar saber sobre matrices para entender todo lo que voy a explicar abajo.

//////////////////////////////////////////////////////////////

Bueno, sabiendo que trabajas con el OpenGL antiguo, te puedo indicar mejor.

Cuando rotas con glTranslatef, los tres últimos parámetros son vectores que representan ejes de rotación. Entonces, en resumidas cuentas, hay que seguir estos pasos:

1º Paso (Opcional): Declarar una estructura llamada vec3, que represente un vector en 3D:

Código (cpp) [Seleccionar] Expandir

struct vec3 {
   float x;
   float y;
   float z;
};

Además de una estructura que represente una matriz de 3x3:

Código (cpp) [Seleccionar] Expandir

struct mat3 {
   float elementos[3][3];
};


2º Paso: Declarar un vector 3D que represente la dirección relativa en la que quieres mover el cubo (en tu caso, como lo quieres mover por el eje X, pues el vector sería (1, 0, 0)):

Código (cpp) [Seleccionar] Expandir

vec3 eje_desplazamiento = {1, 0, 0};

3º Paso: Crear matriz de rotación. Para realizar este paso, debes saber que la matriz de rotación sobre un eje es la siguiente:



Una vez sabido esto, declaramos una función que asigne una matriz de rotación a nuestra matriz:

Código (cpp) [Seleccionar] Expandir

void rotar_matriz(float angulo, mat3& matriz, vec3& eje) {
   matriz.elementos[0][0] = cos(angulo) + pow(eje.x, 2.0)*(1 - cos(angulo));
   matriz.elementos[0][1] = eje.x*eje.y*(1 - cos(angulo)) - eje.z*sin(angulo);
   matriz.elementos[0][2] = eje.x*eje.z*(1 - cos(angulo)) + eje.y*sin(angulo);

   matriz.elementos[1][0] = eje.x*eje.y*(1 - cos(angulo)) + eje.z*sin(angulo);
   matriz.elementos[1][1] = cos(angulo) + pow(eje.y, 2.0)*(1 - cos(angulo));
   matriz.elementos[1][2] = eje.y*eje.z*(1 - cos(angulo)) - eje.x*sin(angulo);

   matriz.elementos[2][0] = eje.x*eje.z*(1 - cos(angulo)) - eje.y*sin(angulo);
   matriz.elementos[2][1] = eje.y*eje.z*(1 - cos(angulo)) + eje.x*sin(angulo);
   matriz.elementos[2][2] = cos(angulo) + pow(eje.z, 2.0)*(1 - cos(angulo));
}

4º Paso: Crear una función (o si quieres sobrecargas el operador *) que multiplique una matriz por un vector:

Código (cpp) [Seleccionar] Expandir

void multiplicar(mat3& matriz, vec3& vector) {
   vec3 resultado = {0, 0, 0};

   resultado.x = matriz.elementos[0][0] * vector.x + matriz.elementos[0][1] * vector.y + matriz.elementos[0][2] * vector.z;
   resultado.y = matriz.elementos[1][0] * vector.x + matriz.elementos[1][1] * vector.y + matriz.elementos[1][2] * vector.z;
   resultado.y = matriz.elementos[2][0] * vector.x + matriz.elementos[2][1] * vector.y + matriz.elementos[2][2] * vector.z;

   vector.x = resultado.x;
   vector.y = resultado.y;
   vector.z = resultado.z;
}

5º Paso: rotar el vector que declaramos en el paso dos tal y como has rotado el cubo:

Código (cpp) [Seleccionar] Expandir

vec3 eje_desplazamiento = {1, 0, 0};
mat3 matriz_rotacion;

rotar_matriz(objPruebas1.rotX, matriz_rotacion, {1, 0, 0});
multiplicar(matriz_rotacion, eje_desplazamiento);
rotar_matriz(objPruebas1.rotY, matriz_rotacion, {0, 1, 0});
multiplicar(matriz_rotacion, eje_desplazamiento);
rotar_matriz(objPruebas1.rotZ, matriz_rotacion, {0, 0, 1}); // Date cuenta que el tercer parametro es el mismo que usabas en glRotatef
multiplicar(matriz_rotacion, eje_desplazamiento);

5º Paso: desplazar el cubo. Ahora ya tenemos el eje donde se desplazará el cubo rotado tal y como hemos rotado el cubo. Ahora tenemos que desplazar el cubo:

Código (c++) [Seleccionar] Expandir

float unidades_a_desplazar = 5.0f; // Aquí pones las unidades que te quieres desplazar. Por ejemplo, yo he puesto 5.0f, pero tu puedes poner el valor que quieras.

eje_desplazamiento.x *= unidades_a_desplazar;
eje_desplazamiento.y *= unidades_a_desplazar;
eje_desplazamiento.z *= unidades_a_desplazar;

glTranslatef(eje_desplazamiento.x, eje_desplazamiento.y, eje_desplazamiento.z);

Como ves, es un proceso relativamente largo, pero si quieres hacerlo manualmente, me temo que no tenemos otra salida.

Supongo que es el código suyo que expuso al principio pero cambiándolo con mis consejos. Vamos, que sería así:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;
using std::exit;

struct alumno {
    char nombre[256];
    char apellido[256];
    int edad;
};

int main () {
int i;
alumno alum[50];

ofstream f;

f.open("alumnos.bin", ios::out | ios::binary);
if(f.open) {
for (i=0; i<=50; i++) {
cout<<"Teclee el nombre del alumno"<<endl;
cin>>alum[i].nombre
cout<<"Teclee  el apellido"<<endl;
cin>>alum[i].apellido;
cout<<"Teclee  la edad"<<endl;
cin>>alum[i].edad;
f.write(reinterpret_cast<const char*>(&alum[i]), sizeof(alumno);
}
} else {
cout<<"Error al abrir el archivo"<<endl;
exit(1);
}
is.close();


//leemos el archivo

ifstream fe("alumnos.bin", ios::in | ios::binary);
if (fe){
cerr<<"Se abrio correctamente"<<endl;
} else {
cout<<"No se abrio correctamente"<<endl;
exit(1);
}

while (fe && !fe.eof()){
for (i=0; i<=50; i++){
cout<<"Teclee el nombre del alumno"<<endl;
cin>>alum[i].nombre
cout<<"Teclee  el apellido"<<endl;
cin>>alum[i].apellido;
cout<<"Teclee  la edad"<<endl;
cin>>alum[i].edad;

fe.read( reinterpret_cast<const char*>(&alum[i]), sizeof(alumno));
}
}//fin del while

return 0;
}

Lo que hace el código es pasarle todos los datos de la estructura al método ofstream::write. Le pasas los datos en forma de array de caracteres (para eso sirve reinterpret_cast). Y si, para cuando leas los datos puedes hacerlo relativamente igual Es lo bueno de ese código!

Las clases tipo string no guardan la cadena de caracteres en la memoria ocupada por la estructura en sí. Para mayor comodidad, declararía la estructura así:

Código (cpp) [Seleccionar] Expandir

struct alumno {
   char nombre[256];
   char apellido[256];
   int edad;
};

Una vez rellenada dicha estructura, es tan simple como copiar byte a byte la memoria de la estructura:

Código (c++) [Seleccionar] Expandir

f.write(reinterpret_cast<const char*>(&alum[i]), sizeof(alumno);

Por si la imagen se cae:
https://mega.nz/#!BNUDxQyJ!jZ7K4moQhvfmh7Lbvsh_0lV-wo9Cgun2ysTA3C9u5R4

No sé si estás usando el OpenGL antiguo o el moderno. No sabiendo eso, lo único que puedo hacer es orientarte. Tampoco sé si para rotar el cubo has usado ángulos, o has rotado el cubo alrededor de un eje.
Si lo has hecho con ángulos, espero que lo hayas hecho con los de Euler.

Si has usado un eje para rotarlo, es bastante simple. Lo único que tienes que hacer es rotar el vector unitario î alrededor de ese eje de rotación usado con el cubo, después multiplicas el resultado por las unidades que te quieres mover, y luego le sumas ese vector resultante a todos los vértices del cubo.

Esta es una representación gráfica:



En pseudocódigo, sería así:

Código [Seleccionar] Expandir

vec3 eje_rotacion = {0.6, 0.4, 0.0} --Este evidentemente es arbitrario
vec3 posicion_cubo = {0, 0, 0} -- También es arbitrario
vec3 vector_unitario = {1, 0, 0} --Este no es arbitrario. Tiene que ser así
float angulo = 0.3 -- Arbritario
float unidades_a_mover = 6.5;

rotar_cubo(eje_rotacion, angulo, posicion_cubo)
rotar_eje(eje_rotacion, angulo, vector_unitario)

trasladar_cubo(posicion_cubo + unidades_a_mover*vector_unitario)

Es difícil de explicar, pues es 3D y solo disponemos (al menos yo) de monitores 2D XDD

Espero que se haya comprendido

[ES POSIBLE, PERO NO SIEMPRE]

Es relativamente posible. Todo depende del compilador que uses. Por ejemplo: si usas short int ES POSIBLE, PERO NO SIEMPRE que su tamaño sea de 16 bits o 2 bytes...

Mira esta tabla:

   
       
       
       

Integer types (signed)
signed char	signed short int	signed int	signed long int	signed long long int
Mismo tamaño que char. Al menos 8 bits.	No es más pequeño que char. Al menos 16 bits.	No es más pequeño que. Al menos 16 bits.	No es más pequeño que int. Al menos 32 bits.	No es más pequeño que long. Al menos 64 bits.

Tabla sacada de http://www.cplusplus.com/doc/tutorial/variables/

[array]

Interesante... ¡Cada día se aprende algo nuevo!
Por si no ha quedado claro, lo que ha dicho ivancea96 es que cuando declaramos un array dentro de una estructura (o clase), todos los datos de ese array estarán dentro de la misma (pero el array seguirá siendo un puntero, esto se explica mejor con ensamblador...), mientras que si declaramos un puntero como tal, entonces (evidentemente), los datos apuntados por ese puntero no estarán dentro de la estructura.

Chicos, recuerden que si bien las cadenas de caracteres son en realidad punteros al primer caracter, cuando la cadena es estática, es almacenada en la propia estructura. En tal caso se guardaría en memoria  TAL CUAL. Si guardas la estructura, tambien se guarda la cadena, no el puntero.

Pues eso no lo sabía. Para probarlo, he elaborado el siguiente código:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

struct FOO {
char lpszName[33];
};

int main() {
FOO foo = {"Esto es una cadena de caracteres"};

std::cout << "Size: " << sizeof(foo) << std::endl;

for(unsigned int i = 0; i < sizeof(foo); i++) {
std::cout << reinterpret_cast<char*>(&foo)[i];
}

std::cin.get();
return 0;
}

el cual imprime byte a byte toda la estructura... Lo que me ha sorprendido es obtener la siguiente salida:

Código [Seleccionar] Expandir

Size: 33
Esto es una cadena de caracteres

Me ha sorprendido, porque no he declarado la cadena como estática, como mencionas en tu respuesta... Espero que alguien pueda aclararlo.

PD.: He usado el compilador de MinGW64 (el g++ de 64 bits para Windows).
Por si aclara algo, no he usado ninguna etiqueta al compilar (vamos, que no lo he compilado como c++11, ni nada parecido...)