elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


  Mostrar Mensajes
Páginas: 1 ... 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 [22] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 ... 88
211  Programación / Programación C/C++ / Re: [Ayuda] guías de c++ en: 24 Mayo 2020, 11:28 am
Haber hay muchas y ya hay algunos temas abiertos en el foro destinados a libros para aprender a programar. Te dejo por aquí algunos enlaces:
https://foro.elhacker.net/dudas_generales/listado_de_libros_para_principiantes-t497312.0.html;msg2197810#msg2197810
https://foro.elhacker.net/programacion_general/que_lenguaje_es_mas_facil_para_aprender-t504547.0.html;msg2221135#msg2221135
https://foro.elhacker.net/programacion_cc/librospapers_cc-t296234.0.html;msg1467269#msg1467269

Aunque el último enlace es muy antiguo y puede que los enlaces de descarga ya no funcionen (no lo sé, no lo he probado), es una recopilación muy grande y siempre puedes buscar los títulos en Google.
212  Programación / Programación C/C++ / Re: Consulta con archivos en C y un arreglo en: 21 Mayo 2020, 08:49 am
Modifique esta funcion y le agregue en la linea 8 el i<2.
Lo que no entiendo es porque funciona mal si en el while en la linea 10, como los nombres no son tan largos, lo primero que va a encontrar es el \n y la linea 21 por mas que la saque queda igual.
Aunque añadas la segunda condición en la línea 8 sigues teniendo el problema que tienes en la función lectura().
Te lo muestro por pasos (función auxiliares()):
Código:
1. i = 0 -> i < 2?? Sí -> Entra a los dos bucles -> Guarda "Juan Perez" -> Sale -> i++
2. i = 1 -> i < 2?? Sí -> Entra a los dos bucles -> Guarda "Graciela Arpe" -> Sale -> i++
3. i = 2 -> i < 2?? No -> Va a la línea 21 -> aux[2][0] = '\0'
Al final accedes a aux[2][0] y tu array es de 2 dimensiones por lo que solo tiene las filas {0,1}. Esto es un acceso fuera de la memoria permitida. Coincide que justo donde acaba tu array aux, empieza el espacio de memoria de arreglo. Entonces el programa accede sin querer a arreglo[0][0] (que repito, el programa calcula la posición de memoria en la que tendría que estar aux[2][0] pero se encuentra con que esa posición es la de arreglo[0][0]) y cambia su valor.

La forma de hacerlo con fgetc para que no pase esto es... haciéndolo bien  :xD. Es decir, tratando correctamente cada posible situación:
Código
  1. i = 0
  2. letra = fgetc(fichero)
  3. while(i < F && letra != NULL){
  4.  j = 0
  5.  // La ultima columna siempre va a tener \0 entonces no hace falta guardar nada del fichero ahi
  6.  while (j < C-1 AND letra != NULL AND letra != '\n'){
  7.    arreglo[i][j] = letra
  8.    ++j
  9.    letra = fgetc(fichero)
  10.  }
  11.  // Una vez salimos, siempre podemos poner el \0 sin miedo a salirnos porque solo hemos ido hasta C-1
  12.  arreglo[i][j] = '\0'
  13.  if(letra != NULL) letra = fgetc(fichero);
  14.  ++i
  15. }
  16. return i

Igual que antes, en vez de poner un 0 en la primera línea vacía, es mejor que devuelvas el número de filas útiles que tiene tu array. Luego guarda dicho valor en una variable y úsalo cuando quieras mostrar el array. Así no malgastas una fila entera para nada.

Si sigo sin convencerte y quieres poner un 0 al final, recorre el bucle de fuera para i < F-1. Así siempre dejarás la última fila libre para poder guardar ese 0.

EDIT: En el código anterior me he dejado el leer otro carácter al salir del bucle interno. Ahora lo corrijo... :rolleyes:
213  Programación / Programación C/C++ / Re: Consulta con archivos en C y un arreglo en: 21 Mayo 2020, 07:45 am
Lo que veo son varios problemas de acceso y eso es lo que está generando tu problema.

Función lectura():
  • Si el bucle de la línea 31 sale porque j == C, en la línea 37 tienes un acceso a memoria fuera de los límites del array.
  • Si el bucle de la línea 29 sale porque i == F, en la línea 42 tienes otro acceso fuera del array.

Además no sé si es obligatorio que hagas así la lectura pero sino es mucho mejor que uses la función fgets():
Código
  1. // Guarda el contenido de un archivo en un array bidimensional por lineas y devuelve el numero de lineas leidas
  2. int lectura(char array[][C]){
  3.  FILE *archivo = fopen("loquesea.txt", "r");
  4.  int fila = 0;
  5.  // fgets guarda C-1 caracteres de una linea del archivo y pone '\0' al final
  6.  while(fila < F && fgets(array[fila], C, archivo)) ++fila;
  7.  return fila;
  8. }

Y en la función auxiliares() tienes los mismos problemas que en lectura() además de que no controlas el límite de líneas leídas. Si el array tiene 2 filas y el fichero tiene n filas estás realizando n-2+1 accesos a memoria fuera del array.
Al ejecutarse la línea 74, el programa se detendría si intenta acceder a memoria fuera del ámbito de tu ejecutable. Si no se detiene está modificando algo y en tu caso ese algo es el elemento arreglo[0][0].
214  Seguridad Informática / WarZone / Re: ¿Donde podria encontrar otro sitio parecido al warzone? en: 18 Mayo 2020, 23:12 pm
Buscando CTF (Capture The Flag) en Internet no deberías de tener problemas para encontrar lugares similares.
Si te aparecen enlaces al tradicional juego de capturar la bandera, añade "hacking" o algo por el estilo a la búsqueda.

Espero que te sirva.
Suerte.
215  Programación / Programación C/C++ / Re: Dividir polinomio en monomios C++ en: 18 Mayo 2020, 22:01 pm
Muchas gracias, no entiendo muy bien a que te refieres con la primera linea la de validar monomio.
La estructura del monomio seria así?
Código:
struct monomio {
int coeficiente;
int exponente;
};
Y como puedo guardar los monomios en la estructura?

La primera línea era solo para definir una función llamada validarMonomio() que recibe como parámetro un string y devuelve un Monomio. El prototipo de la función sería:
Código
  1. Monomio validarMonomio(string monomio);



Para usar la struct Monomio:
Código
  1. struct Monomio {
  2.  int coeficiente;
  3.  int exponente;
  4. };
  5.  
  6. int main(){
  7.  Monomio mon;
  8.  int coeficiente = 2, exponente = 5;
  9.  mon.coeficiente = coeficiente;
  10.  mon.exponente = exponente;
  11. }

También puedes crear constructores, gets()/sets(),... Incluso crear una class para hacer los atributos privados y manejar los objetos a partir de los métodos.
216  Programación / Programación C/C++ / Re: Dividir polinomio en monomios C++ en: 18 Mayo 2020, 17:05 pm
La estructura que debe tener el monomio es:
```
1. Signo + o -
2. COEFICIENTE: uno o mas dígitos enteros (0,...,9)
3. x
4. signo ^
5. EXPONENTE: uno o mas dígitos enteros (0,...,9)
```

Esta estructura que dices que debe cumplirse no se cumple. Casos:
  • Término independiente -> solo tiene signo y coeficiente.
  • Monomio grado 1 -> solo tiene signo, coeficiente y x.


De todas maneras, una vez que ya lo tienes separado en monomios, te digo cómo puedes validar cada uno de estos. Mi recomendación es que crees una clase Monomio con coeficiente y exponente. Así podrás manejar los datos fácilmente y no desperdigarlos. Una idea del algoritmo sería:
Código:
validarMonomio(string) : Monomio // Funcion que recibe un string (monomio) y devuelve un objeto de tipo Monomio
INICIO
  exponente = 0 // Exponente por defecto
  i := 1 // El 0 ya sabes que es '+' o '-'
  // Calcular la longitud del coeficiente:
  MIENTRAS i < monomio.size() AND es_digito(monomio[i]) HACER // Recuerda la primera condicion para no salirte del string
    i := i + 1
  FIN MIENTRAS
  SI i = 1 ENTONCES // No hay digitos despues del signo
    Mostrar Error
    Salir
  FIN SI
  coeficiente = monomio.substring(0, i)  // Ya tienes el COEFICIENTE y con signo

  // Comprobar si es el termino independiente:
  SI i < monomio.size() ENTONCES // Si no acaba ahi y entonces no es el termino independiente...
    SI monomio[i] != 'x' ENTONCES // ...debe continuar con una 'x'
      Mostrar Error
      Salir
    FIN SI
    coeficiente = 1 // y ahora el coeficiente por defecto sera 1, no 0
    i := i + 1

    // Si no acaba con la x, tiene que seguir '^' y el exponente
    SI i < monomio.size() ENTONCES
      SI monomio[i] != '^' ENTONCES
        Mostrar Error
        Salir
      FIN SI

      // Procedemos a calcular el exponente
      i := i + 1
      inicio := i
      MIENTRAS i < monomio.size() AND es_digito(monomio[i]) HACER
        i := i + 1
      FIN MIENTRAS
   
      // Si no hay digitos despues de '^' o hay algo mas despues de los digitos, esta mal
      SI i = inicio OR i < monomio.size() ENTONCES
        Mostrar Error
        Salir
      FIN SI
      exponente = monomio.substring(inicio, i) // Ya tienes el EXPONENTE
    FIN SI
  FIN SI

  RETURN new Monomio(coeficiente, exponente)
FIN

Es un poco largo pero no lo podía probar así que he ido separando y explicando cada posible situación para procurar no dejarme nada.
Ahora pásalo a C++ y si te da algún problema, coméntalo.
Suerte.

PD: Además puede darse que tengas varios monomios del mismo grado (como en tu ejemplo: -4 y +1). Una vez separados todos, deberías comprobarlo y juntarlos.
217  Programación / Programación C/C++ / matriz transpuesta c en: 18 Mayo 2020, 15:09 pm
El mensaje 'matriz transpuesta c  ' fue bloqueado
Reapertura de tema antiguo
Leer reglas:
http://foro.elhacker.net/reglas
218  Programación / Programación C/C++ / Re: Dividir cadena en subcadena C++ en: 17 Mayo 2020, 19:27 pm
Además de la opción que ya te ha dado EdePC para la que no necesitas de funciones preexistentes; hay otras opciones como utilizar la función strtok(): https://en.cppreference.com/w/cpp/string/byte/strtok que permite separar una cadena de caracteres en base a una serie de limitadores que puedes establecer tú (en este caso: "a").

Fíjate en su uso ya que es un poco peculiar.

Suerte.
219  Programación / Programación C/C++ / Re: Comparar matrices en: 17 Mayo 2020, 19:16 pm
El problema está en que en la parte de verificar si son iguales o no, lo que realmente estás haciendo es comprobar si el último elemento de la matriz es igual o no. Para comprobarlo correctamente puedes hacerlo declarando una variable de tipo bool y usándola como condición de salida de los bucles:
Código
  1. bool iguales = true;
  2. for(int i = 0; i < filas && iguales; ++i){
  3.  for(int j = 0; j < columnas && iguales; ++j){
  4.    iguales = (matriz1[i][j] == matriz2[i][j]);
  5.  }
  6. }
  7.  
  8. if(iguales)
  9.  cout << "Las matrices son iguales" << endl;
  10. else
  11.  cout << "Las matrices no son iguales" << endl;


Además de eso, otras mejoras serían:
  • No utilizar un char[] para guardar la respuesta. Si solo es un carácter, usa un char.
  • Para comparar varias cadenas char[] es mejor usar strncmp() que strcmp(). La primera permite indicar la cantidad de caracteres a comparar.
  • C++ tiene la ventaja de las variables tipo <string>. Úsalas y te ahorrarás quebraderos de cabeza con char[].
  • Declara el tamaño de las matrices como constantes. Así podrás modificar su tamaño modificando el valor en un único lugar.
Código
  1. // cabeceras...
  2. const int FILAS = 3;
  3. const int COLUMNAS = 3;
  4.  
  5. int main(){
  6.  int matriz[FILAS][COLUMNAS];
  7.  //...
  8. }

  • Para pedir los valores al usuario, utiliza un bucle. Así valdrá para cualquier tamaño y te ahorras las variables auxiliares:
Código
  1. for(int i = 0; i < FILAS; ++i){
  2.  for(int j = 0; j < COLUMNAS; ++j){
  3.    cout << "Introduce el valor M[" << i << "][" << j << "]: ";
  4.    cin >> matriz[i][j];
  5.  }
  6. }
220  Programación / Programación C/C++ / Re: Fallo al dar valores a un array de chars en: 16 Mayo 2020, 03:24 am
Hay varias incorrecciones pero digamos que el problema principal está en el operador =. Cuando se trabaja con punteros el operador = hace que el puntero de la izquierda apunte a la dirección de memoria que se especifique a la derecha.
En tu caso, cada uno de los punteros del array <array> están apuntando a la dirección de memoria de <input> e <input> contiene la última cadena introducida por la entrada estándar. Por lo tanto, todos los punteros del array están apuntando a una misma cadena, cuando muestras todas en el último bucle estás mostrando la misma cadena (<input>) n veces.

Otro error es el de usar un array de punteros. Como ves esto no sirve pues todos los punteros acabarán apuntando a un mismo sitio y cuando cambies el valor de esa variable, perderás todos los anteriores.
La solución: usar una matriz. Cada fila será una entrada y cada columna un carácter.
Código
  1. #define MAX_ENTRADAS 20 // Numero maximo de entradas por teclado
  2. #define MAX_LONGITUD 50 // Longitud maxima de cada entrada
  3.  
  4. int main(){
  5.  char matriz[MAX_ENTRADAS][MAX_LONGITUD];
  6. }
Aprovecho el código para decirte que utilices mejor constantes. Así si en algún momento quieres cambiar un valor, solo tendrás que cambiarlo en el lugar en el que lo has declarado.

Además de eso, otra incorrección es utilizar sscanf() para eliminar el salto de línea final (que supongo que lo haces para eso). Esto no es válido porque sscanf() no recoge los espacios por lo que una cadena con espacios (ej: "hola mundo") la truncará al primer espacio que encuentre ("hola").
Una alternativa para hacerlo es la siguiente:
Código
  1. #define SIZE 100
  2. //...
  3. char entrada[SIZE];
  4. fgets(entrada, SIZE, stdin);
  5. if(entrada[strlen(entrada)-1] == '\n') // el ultimo caracter siempre es '\0'. Entonces si el anterior es un salto de linea '\n'...
  6.  entrada[strlen(entrada)-1] = '\0'; // ... le pones el fin de cadena uno antes para eliminar el '\n'
  7.  

Otra cuestión es el tema de comparar cadenas. Si utilizas strcmp() y usas una longitud máxima de 5, al escribir "exit\n" solo se va a guardar "exit" y al compararlo no va a coincidir. Por esto es más seguro utilizar strncmp():
Código
  1. strncmp(matriz[n], "exit\n", strlen(matriz[n]))
Así compararás tantos caracteres como tenga la primera cadena. Si introduces "exit\n" y solo se guarda "exit", se compararán los 4 primeros caracteres de cada cadena y por tanto saldrá del bucle. Además si introduces "ex" pensando que va a comparar los dos primeros de la cadena, no saldrá porque comparará "ex\n" con "exi".

Y para futuras ocasiones, para copiar el contenido de una cadena en otra, tienes que utilizar las funciones strcpy() o strncpy(). Recomendable usar la segunda ya que puedes especificar la longitud.

Dicho esto puedes utilizar algo así:
Código
  1. while(n < MAX_ENTRADAS && fgets(matriz[n], MAX_LONGITUD, stdin) && strncmp(matriz[n], "exit\n", strlen(matriz[n]))){
  2.    if(matriz[n][strlen(matriz[n])-1] == '\n')
  3.        matriz[n][strlen(matriz[n])-1] = '\0';
  4.    ++n;
  5. }
Como puedes ver te ahorras los otros arrays auxiliares. Y debes comprobar primero que n no sobrepase el límite de entradas para que matriz[n] no produzca un error en memoria al intentar acceder a espacio de memoria no permitido.
Páginas: 1 ... 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 [22] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 ... 88
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines