Mensajes

Xcode es un IDE, de manera que ya estás usando uno

"Integrated - Development - Enviroment"

Entorno de desarrollo integrado, ya estás usando uno, no hay mas.

En Mac no se como anda el tema de compiladores, en Windows te recomiento el minGW-w64

http://mingw-w64.sourceforge.net/

Funciona en 32 y 64 bits. Como IDE para windows, el mismo codebloks te vale, a menos que quieras hacer proyectos mas grandes sobre entorno windows, donde ya sería recomentable empezar a pensar en un Visual Studio de Microsoft (que ahora creo que es gratis en alguna de sus versiones)

Ojo, algunas instalaciones de XP no contienen la parte relativa al manejo de particiones, pero otras si. Vamos, he instalado XP montones de veces en docenas de ordenadores, y he visto siempre la sección donde te deja elegir unidad de destino, y ahi te permite eliminar particiones y crear otras. Da igual el tipo de partición, si te aparecen como "desconocidas" simplemente se borran todas, se crea una nueva con el tamaño máximo y a partir de ahi empieza a formatear.

Lo que ya no puedo poner la mano en el fuego, es que todas las instalaciones de XP tengan esa parte.

A ver... esto es bastante sencillo.

Sea el array (o arreglo) char A[15];

Esto es un array de 15 casillas, cada una con un carácter, en casillas que van desde la 0 a la 14

Tal que... si queremos escribir algo en ellas:

Código [Seleccionar] Expandir

A[0] = 'x';
A[1] = '1';

Donde van números puede ir una variable de tipo entero, tan simple como eso.

¿quieres sacar lo que hay dentro? Mismo sistema

Código [Seleccionar] Expandir


char B = A[0];
// o a otro array:
char B[5] = A[1]
cout << B[5]
// etc...


No tiene mas misterio, solo dos cosas. Una es acordarte de que van de 0 a la longitud -1. Eso ya te lo comenté antes.

La otra es que como todas las variables, cuando se inicializan contienen valores aleatorios, pueden tener dentro cualquier cosa a menos que las inicialices con algún valor.

Es posible (por ejemplo)

Código [Seleccionar] Expandir


int a[5] = {1, 2, 3, 4, 5};


Y otra cosa, un array contiene lo que tu quieras, si haces un array de 15 casillas, puedes usar las que están de la 0 a la 13 para 14 resultados, y la 14 (la última) para el final (pleno al 15)

Los booleanos no tienen misterio, son un tipo de variable que solo acepta dos valores: cero "u otro". Ese otro, si no es 0 se asume como "true"

Es un poco "tonto" porque si haces algo como:

Código [Seleccionar] Expandir


bool a = 0;
bool b = 6;


En realidad "b" es "true", porque no es cero. Es un poco "tonto", pero es asi

Y se usan precisamente en los if. Cuando evaluas una condición dentro de un if, lo que haces es evaluar si la condición es falsa o verdadera. Tan simple como eso.

Es decir, que si tienes un bool tal que:

Código [Seleccionar] Expandir


bool a = true;  // También pueden inicializarse así
bool b = false;
if (a) cout << "A es verdadera" << endl;
if(!b) cout << "B es falsa";


Vale... un momento. ¿Como es que en el "if" no hay una expresión?. Porque el resultado de una expresión es verdadero, o falso. Si ponemos directamente en el if algo que es verdadero, se da como "buena" la respuesta. En el segundo caso he puesto !b, y como ese operador niega lo que le sigue, como "b" es falso, si lo negamos es verdadero, y el if lo da "como bueno".

Ten en cuenta que este tipo de expresiones se usa mucho, pero mucho en C++, es normal poner como condición en un if, o en un while un comando que si se ejecuta, devuelve "true" (o false).

Por ejemplo:

Código [Seleccionar] Expandir


int A;
while (cin >> A) { cout << A << ' ';}


Raro ¿no?... pero no tanto, ya que cin puede tener o no éxito. Si introduces un dato, el while se cumple.

Intenta ejemplos y programas sencillos para ir pillando "mano" con estas cosas, sobre todo con los diferentes tipos, arreglos y demás, que luego las cosas se ponen divertidas.

También es importante usar un IDE que te facilite el trabajo, y ojo, si estás usando Codeblocks ten en cuenta que el compilador por defecto que trae, a menos que lo hayan cambiado te dará mas adelante algún problema y conviene usar otro (minGW64 por ejemplo)

Vale... he podido con todos los problemas que he encontrado en el "cursillo" que estoy siguiendo, pero este confieso que me ha dejado a cuadros.

Tenemos un vector tal que

Código [Seleccionar] Expandir


vector<vector<int> > Datos;


A menos que me equivoque mucho, un iterador para este vector (para lo que serían "filas" del mismo)

Sería tal que...

Código [Seleccionar] Expandir


vector<vector<int> >::iterator it


Suponiendo que eso este bien... ¿como accedo pues por ejemplo al tamaño de las "filas" del vector?

Porque algo como it.size() obviamente no funciona, ni *it.size() ni cualquier otra cosa que se me ocurra.

O lo mismo es que el mismo iterador está mal planteado, pero como este es uno de esos casos "raros" que no te aparecen en ejemplos por ningún lado, me pasa lo que me pasa, que llevo un par de horas dándome cabezazos contra la pared (contra el teclado no, que el jodio es caro)

Ya ni me atrevo a preguntar como hago un iterador para alguno de los vectores anidados en el vector... pero si alguien sabe donde puedo encontrar ejemplos de esta atrocidad, o explicarme "como se come esto" espero que Dios se lo pague con muchos hijos.

O al menos con intentos, que es mas divertido

Desde luego, en un caso general no tiene mayor problema, ahí estoy de acuerdo, pero las quinielas... bueno, son 14+1, no hablamos de una rutina de uso general.

Claro, es cuestión de gustos y opiniones, aquí podemos terminar hablando del sexo de los ángeles. Claro que es correcto, solo que para un programa tan simple es innecesario.

Pero vamos, esto es como los culos, todos tenemos uno y creemos que el de los demás no es tan bonito 

[siempre]

Te pongo un ejemplo:

Código [Seleccionar] Expandir


int main() {
    char apuestas [15], resultados [15];
    int i;

    for (i=0; i < 15; i++){
        cout << "\n Introduce 1 X 2 según la apuesta, "<< i+1 <<": ";
        cin >> apuestas[i] ;
    }

    for (i = 0; i<15; i++){
        cout << "\n Introduce ahora los resultados de la semana, partido " << i+1 << ": ";
        cin >> resultados [i];
    }

   bool acierto=true;
   bool complementario=true;

    for (i=0; i<14; i++){
        if (apuestas[i] != resultados[i]) acierto = false;
    }
    if (apuestas[14] != resultados[14]) complementario = false;
    cout << acierto << ' ' << complementario;
}



Está incompleto al final, pero seguro que te las apañas.

Unas cosillas. Usar un "define" en la cabecera es matar moscas a cañonazos. Podemos hacerlo claro, pero es un poco... exagerado, aunque supongo que eso va por gustos.

Recuerda que ambos arreglos (o arrays, o como quieras llamarlos) deben de tener el mismo número de elementos. No tiene sentido que "apuestas" tenga 15 casillas, y resultados 16.

No necesitas diferentes variables para bucles, a menos que estén anidados. Puedes usar la misma variable de tipo entero "i" para todos, e incluso declararla en el mismo bucle

En plan:

Código [Seleccionar] Expandir

for (int i=0; i<15; i++)

Recuerda que las tablas empiezan en el 0, no en el 1. El ejemplo anterior te haría un bucle entre la casilla 0 y la 14, lo que nos da un total de 15 casillas, de las cuales las primeras 14 son para los resultados normales, y la 15 (que ojo, es la casilla 14) sería para el pleno al 15.

Esto al principio suele liar, es solo cuestión de acostumbrarse. Acuerdate siempre de que todos los contenedores, ya sean arrays de enteros, caracteres o cualquier otra cosa (incluso strings, vectores, etc...) empiezan siempre en el '0'.

Es decir: (insisto), que un array "apuestas[15]" empieza en el 0 y llega al 14. Si intentas leer o escribir fuera de esos límites de arriesgas como poco a resultados imprevistos, o a que el programa explote.

Luego, la comparación la has hecho entre dos "indices", no entre los valores que contienen los arrays. Para eso verás que he definido dos variables de tipo bool, y hago un bucle de 0 a 13 (0<14) para comprobar cada uno, y si alguno es diferente cambio la condición a falso.

Y lo mismo hago, pero sin bucle con la última casilla de los dos arreglos, comparando así la casilla del "pleno al 15"

Esto:

Código [Seleccionar] Expandir


if (r == i)


Literalmente  está comparando dos variables de tipo entero, que son las que has usado para los dos bucles, pero no el contenido de los arrays.

El resultado son dos "1", pero si la condición de cualquiera de los dos no se cumple, te saldría un "0"

Claro, hay otras maneras, pero esta es una sencilla, a partir de ahí puedes montar un "if" que saque un resultado u otro dependiendo de esta variable.

Mas refinamientos sería poner (por ejemplo) un contador de aciertos, o sacar por pantalla por un lado la apuesta y al lado el resultado y cosas así, pero eso ya te lo dejo para que practiques.

Esto debería de funcionarte, a menos que haya metido gloriosamente la pata de forma inadvertida por algún lado.

Normalmente durante la instalación del XP llegas a un lugar donde puedes decir en que partición quieres que se instale, y en la misma te permite eliminar todas las particiones y crear una nueva con todo el espacio disponible.

Que es lo que deberías de hacer

[no es correcto]

Vale... ahora he entendido realmente porque hay que usar el método de igualar.

Lo pongo para los que se encuentren con este problema, porque el motivo es cuando menos... "curioso" y si a mi me ha pasado, supongo que les pasará a mas personas.

El caso que tenía:

Código [Seleccionar] Expandir


int main() {
    vector<int> A = {1, 2, 3, 4, 5, 6, 7, 8};
    vector<int>::iterator it = A.begin();
    cout << *it;
    A.erase(it);
    cout << *it;
}


Funciona, pero no es correcto

Código [Seleccionar] Expandir


int main() {
    vector<int> A = {1, 2, 3, 4, 5, 6, 7, 8};
    vector<int>::iterator it = A.begin();
    cout << *it;
    it = A.erase(it);
    cout << *it;
}


Así es correcto.

El motivo (que tiene cojones) es que el iterador en realidad apunta a una posición de memoria. Esto puede parecer algo irrelevante, ya que para nosotros el iterador apunta a una casilla del vector.

Pero... ah... pero el sistema puede mover el vector de unas posiciones de memoria a otras sin avisarnos para optimizar el uso de la memoria. En operaciones de borrado por lo general no debería de haber problemas, pero cuando insertamos en lugar de borrar, el vector aumenta de tamaño, al aumentar de tamaño ocupa mas memoria y si no puede hacerse mas grande en la posición en la que se encuentra, porque los bloques contiguos están ocupados por otras variables (o por lo que sea), el sistema mueve todo el vector a otras posiciónes de memoria.

Y claro, mueve el vector... pero el iterador se queda "mirando para Cuenca" por decirlo de algún modo. Se queda apuntando a una posición de memoria donde el vector puede ya no estar.

Haciendo estas operaciones como asignaciones, los métodos de insert y erase devuelven un iterador que siempre apunta al vector resultante . Se mueva o no el vector en la memoria.

Y yo que creía que lo había entendido... pero solo a medias 

¿La controladora está en modo AHCI?

http://es.wikipedia.org/wiki/AHCI

Ahaha... claro como el agua.

Da gusto cuando las cosas al final no solo funcionan, sino que además sabes porque lo hacen