Mensajes

Código (cpp) [Seleccionar] Expandir


private:
int tamano;
int arreglo[tamano];


llegados a ese punto... que valor tiene "tamano"?? obviamente es desconocido, luego esa definición está, directamente, mal hecha.

Código (cpp) [Seleccionar] Expandir

int * arreglo;

Definir el arreglo de esta otra forma ya es otra cosa... además, queda claro que si el tamaño se puede modificar sobre la marcha, lo lógico es que el arreglo sea directamente dinámico, no?? si fuese de tamaño constante no tendría sentido la variable "tamano".

Dado que el arreglo tienes que crearlo de forma dinámica, tendrás que usar "new" y "delete"... su uso no podía ser más simple:

Código (cpp) [Seleccionar] Expandir


// Creacion
arreglo = new int[tamano];

// Destruccion
delete[] arreglo;
arreglo = 0;

En cualquier caso, debes fijarte en que, por su condición de arreglo, automáticamente pasas a usar punteros... cosa que no estás teniendo en cuenta ni en el constructor ni en "SetArreglo".

Un comentario sobre el diseño:
--------------------------
Vas a empezar a usar memoria dinámica en esta clase, tienes que tener, por tanto, muy claros los ciclos de vida de dicha memoria... dicho de otra forma:

* Cuándo se va a reservar la memoria?
* Cuándo deja de ser necesaria?
* Quién se encarga de liberarla?

Cada vez que tu llames a "SetArreglo", si no controlas bien el ciclo de vida, vas a dejar lagunas de memoria en el programa... y eso queda francamente feo. Además, deberías ir pensando en implementar el destructor.

Lo más lógico es que "Arreglo" se encargue de la gestión de la memoria... es decir, si no le pasas un arreglo entonces el crea uno internamente con el tamaño pedido... cada vez que se llama a "SetArreglo" se ha de eliminar el arreglo anterior... y, por supuesto, si se destruye la instancia, se ha de liberar la memoria reservada por "arreglo".
--------------------------

Un saludo.

Cierto, me confundí con fortran.

En cualquier caso, el fundamento es el mismo... en el caso de una matriz bidimensional tienes que proporcionar el tamaño del bloque, da igual que sea filas o columnas.

En el caso de un vector no es necesario indicar ningún tamaño porque no hay bloques... solo un buffer de tamaño desconocido para el compilador ( no olvidemos que el parámetro que se pasa no deja de ser un puntero, independientemente de que el argumento sea un vector o una matriz )

Lo mismo deberías empezar por cosas más sencillas y dejar esto para cuando tengas más rodaje.

A mí si me funciona.

Por cierto, fflush está pensado para buffers de salida, no de entrada... cuidado con eso.

Echa un vistazo al hilo que trata sobre el tema: http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html

[mientras]

While se ejecuta continuamente hasta que se cumple la condición.

inciso: "While se ejecuta continuamente mientras se cumple la condición"

Si quieres borrar un registro tienes dos opciones:

* Reescribes completamente el fichero evitando guardar el registro borrado.

* con fseek te colocas al inicio del registro y sobreescribes su contenido de tal forma que al leerlo puedas identificarlo como un registro borrado y puedas ignorarlo ( por ejemplo dejando el nombre vacío ).

Si quieres modificar un registro tienes también dos opciones:

* Reescribes completamente el fichero con los nuevos datos.

* con fseek te colocas al inicio del registro y sobreescribes su contenido con la información actual.

Como ves la opción elegida te sirve para ambos cometidos. La primera es más sencilla de implementar pero también más lenta... la segunda es más rápida y eficiente... pero requiere algo más de código por tu parte.

El motivo es porque la memoria en el caso de las matrices se alinea por columnas ( o filas, depende de cómo se mire ). Me explico.

Si defines una matriz tal que int matriz[3][2]; en memoria se crea el siguiente mapa:

Código [Seleccionar] Expandir

[0,0][1,0][2,0][0,1][1,1][2,1]

Como se ve, el tamaño de cada "bloque" se corresponde con el primer valor ( filas o columnas a gusto del consumidor )... el segundo valor determina el número de bloques.

Al compilador le da igual (por que no lo va a comprobar) cual es el tamaño real del buffer. Únicamente necesita conocer el tamaño de cada "bloque" para poder calcular el desplazamiento ... el número de bloques es irrelevante para él... si te pasas ya se encargará el SO de darte un par de collejas.

sprintf gestiona cadenas de caracteres, no imágenes.

Si estás empleando un interfaz gráfico, tu solución pasará por utilizar funciones propias de dicho interfaz... sin conocerlo es complicado dar una solución buena.

Reglas del foro: No se hacen tareas. Esto viene a decir que no voy a poner código.

La idea es coger una serie de variables del sistema (número de serie del disco duro, identificador de la placa base, cantidad de memoria RAM, versión del kernel, loqueseteocurra ) y pasarlos por un algoritmo para que genere un código a tu antojo.

Ese es el código que te tienen que proporcionar.

Tú coges ese código y le aplicas otro algoritmo que saque un hash también a tu antojo. Este código es el que devuelves al cliente.

Tu programa recibe ese código y verifica que es el resultado de aplicar exactamente la misma operación.

Precauciones:

* El mecanismo es muy sencillo de piratear
* Si eliges variables cambiantes ( fecha y hora, aplicaciones instaladas, ... ) a la hora de generar el código que te han de proporcionar es probable que falle el proceso de validación al cambiar el estado de dichas variables.

Posibles mejoras:

* Si usas un sistema de cifrado asimétrico puedes generar la clave a partir de los datos que introduzca el usuario( nombre, dirección de correo, ... ). En tu aplicación almacenas la clave pública y tu generas el hash a partir de la clave privada. La ventaja de este sistema es que ya no resulta sencillo obtener el código de desbloqueo analizando la aplicación. La desventaja de esto es que a la mismas entradas les corresponderá la misma clave de desbloqueo.

* Lo anterior se puede mejorar añadiendo un valor propio de la máquina ( id de la tarjeta gráfica, del procesador o del disco ). Desventaja: Si se cambia ese componente, fallará la validación.

Como ves, no hay una solución que no de algún tipo de problema.

cuando tienes que hacerle una pregunta al código, la solución es un if o un switch.

En tu caso, la opción lógica es un if.

Lo primero que necesitas es una variable para controlar si el carácter anterior era un espacio o no... algo tipo int espacio = 0; te valdría.

Después tienes que meter un bucle for que recorra toda la "frase". Recuerda que una cadena SIEMPRE termina con el carácter nulo '\0'. En cada iteración del bucle tienes que comprobar el valor de "espacio" y actuar en consecuencia... y no olvidarte de volver a actualizar "espacio".

Código (c) [Seleccionar] Expandir


int espacio = 0;
int i;
for ( i = 0; frase[ i ] != '\0'; i++ )
{
  if ( espacio )
  {
    // A mayusculas
  }
  else
  {
    // A minusculas
  }

  espacio = ( frase[ i ] == ' ' );
}