Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - K-YreX

#621
Lo primero de todo coloca el código entre etiquetas de código GeSHi (encima del cuadro de texto tienes un desplegable dónde elegir el lenguaje apropiado)...

Y bueno, has creado todas las funciones dentro de una clase lo que luego complica más la forma de usarlas. Creo que sería más correcto dejarlo sólo como funciones sin meterlas dentro de una clase...

Un par de errores tontos que no te habrás dado cuenta al escribirlo:
  • En el <main> has usado <menuMensaje()> cuando no existe esa función.
  • En el <main> tienes dos <if> seguidos que comprueban lo mismo.
  • El cálculo del perímetro del paralelogramo no está bien...

    Los menús te recomiendo hacerlos que muestren las opciones y devuelvan la que el usuario toma. Así puedes además hacer un filtro dentro de la propia función para que el usuario no introduzca valores no permitidos.
    Código (cpp) [Seleccionar]

    int menuPrincipal(){
        int opcion;
        do{
            cout << "1. Calcular perimetro" << endl;
            cout << "2. Calcular area" << endl;
            cout << "3. Salir" << endl;
            cout << "Opcion: ";
            cin >> opcion;
        }   while(opcion < 1 || opcion > 3);
        return opcion;
    }

    int main(){
        int opcion1 = menuPrincipal();
        if(opcion1 == 3)
            return 1;
        int opcion2 = menuSecundario(); // en este muestras las figuras disponibles con un esquema similar al anterior
        switch(opcion2){
            case 1:
                if(opcion1 == 1)
                    // calculas el perimetro de la figura 1 elegida en la opcion 2
                else
                    // calculas el area de la figura 1 elegida en la opcion 2
                break;

            case 2:
                    // igual que antes con la figura 2
                 break;

             // asi con cada figura
        }
    }


    Creo que te he dejado una plantilla bastante completita. Ahora sólo queda que la completes a tu gusto... :-X :-X
#622
No entiendo muy bien lo que pretendes hacer, ni lo que haces, ya que lo que estás guardando es {"Var1" / "Var2" / "Var3"} pero en ningún momento estás guardando los números con el "=".
Además <palabra> es un <char> cuando creo que lo que querías es que fuera un array de <char>.

Y creo que esto no se cumple nunca:

palabra += read;
strcmp(palabra, DATA_B[0]) == 0  && read == '='

Porque cuando <palabra> es igual a <DATA_B[0]> ("Var1") en <read> todavía tienes almacenado el "1".
Cuando en <read> tienes almacenado el "=", en <palabra> ya tendrías "Var1=" (asumiendo que corrijas lo de que <palabra> es un array). 
#623
Cita de: Phoiinex en  2 Abril 2019, 20:16 PM
Hola,
Soy nuevo en esto de la programación, vi tu duda y me pareció un buen reto el  poder encontrar solución tanto al programa, como a tus dudas, espero haber ayudado.
Código (cpp) [Seleccionar]

#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
int arreglo[5], i, numero = 5, positivos = 0, negativos = 0,  mayor = 0, menor = 0, posicion = 0, posicion1 = 0,x;
int pos[5] = {}, neg[5] = {};//inicializamos todas las posiciones en 0, ya que por defecto el compilador inicializa los elementos que no tienen un valor específico.



for (i = 0; i < numero; i++)//Se llena el arreglo con los 10 elementos que le pones
{
printf("Introduzca numero: \n");
cin >>arreglo[i];

     //vamos guardando en nuestros array auxiliares los valor negativos y positivos
if (arreglo[i] > 0) {
pos[i] = arreglo[i];


}else {
neg[i] = arreglo[i];
}

}

for (i = 0; i < numero; i++) {

if (arreglo[i] > mayor) {
mayor = arreglo[i];
posicion = i;

}

if (arreglo[i] < menor) {
menor = arreglo[i];
posicion1 = i;

}
}

for (i = 0; i < numero; i++)
{
if (arreglo[i] > 0)
positivos += arreglo[i];

}


for (i = 0; i < numero; i++)
{
if (arreglo[i] < 0)
negativos += arreglo[i];

}


//Salidas por pantalla
cout << "Los numero positivos son: ";
for (i = 0; i < numero; i++) //bucle que nos permitira imprimir todos los numero positivos como negativos
{
if (pos[i] > 0)   
{
cout << (pos[i]) << "  ";
}
}
printf("\nSuma de numeros positivos: %d", positivos);
printf("\nEl numero mayor es: %d y se encuentra en la posicion: %d", mayor, posicion);

cout << "\nLos numero negativos son: ";
for (i = 0; i < numero; i++) //bucle que nos permitira imprimir todos los numero positivos como negativos
{
if (neg[i] < 0)
{
cout << (neg[i]) << "  ";
}

}
printf("\nSuma de numeros negativos: %d", negativos);
printf("\nEl numero menor es: %d y se encuentra en la posicion: %d", menor, posicion1);

return 0;
}
 
Ya que estás empezando vamos a comentar el programa aunque he de decir que no se hacen tareas por lo que no deberías haber puesto tu código tan pronto. De todos modos tiene algunos fallos así que vamos a verlos. Al final dejo otras correcciones aunque no son errores como tal está bien corregirlos también:
  • ¿Has probado a ejecutarlo?
    Cuando muestras los negativos y los positivos, seguro que no aparecen como esperarías. Estás guardando valores en dos arrays/arreglos distintos por lo que cada uno va  a su "ritmo". No puedes usar sólo el contador <i>. Piénsalo a ver.
  • Problema si todos los valores son positivos o si todos los valores son negativos
    Estás igual que al principio. Si ponemos <maximo = 0> y <minimo = 0>, si introducimos todo números positivos nos va a dar como resultado que el más pequeño es 0 cuando no lo es y si introducimos todo números negativos, nos va a dar que el máximo es 0 cuando tampoco lo es.

    No sé si me he dejado algún error más, pero los más visibles son esos.


    Ahora vamos a ver algunos detalles:
  • La librería <conio.h>
    Esa librería no es estándar por lo que no todos los compiladores pueden usarla y es una librería que no es necesaria. La función más común de esa librería suele ser <getch()> que podemos sustituir por <getchar()> que se encuentra en <stdio.h> (en C) o <cstdio> (en C++) o por <cin.get()> que se encuentra en <iostream> en C++.
  • Mezcla de <printf()> y <cout>
    <printf()> es una función incluida en <stdio.h> (en C) y <cstdio> (en C++). Sin embargo es más típica de C ya que en C++ se suele optar por usar <cin> y <cout> (incluído en <iostream>) para entrada y salida sustituyendo a <printf()> y <scanf()> de C.
  • Uso de constantes
    No se recomienda usar "números mágicos", es decir, números literales que aparecen de repente y no sabes por qué tienen ese valor. ¿Por qué un 5? Imagina que tienes un programa muy grande y tienes muchos arrays/arreglos de tamaño 5 y un día dices "voy a aumentar la capacidad a 10", tendrías que sustituir todos los "5" por "10" con cuidado de que haya algún 5 que no tengas que cambiar. Para ello usa constantes y sólo tendrás que cambiar el valor de la constante una vez para que cambie en todo el programa.
    Código (cpp) [Seleccionar]

    const int MAX_SIZE = 5;
    int main(){
        int array[MAX_SIZE];
        // ...
    }

    PD: La variable <numeros = 5> es lo que hace en tu caso de constante pero no lo aprovechas tanto como podrías/deberías (además constante mejor para asegurarte de que no vas a cambiar su valor por error).
  • Nombres de las variables
    Asegúrate de que puedes saber qué indica una variable leyendo únicamente su nombre y no porque lo hayas programado tú y te acuerdes que "x" es tal cosa.
    PD: Tienes una variable <x> que no usas en todo el programa me parece.
    Por ejemplo el array de <pos> podría dar lugar a equivocación ya que "posiciones" se suele abreviar como "pos" en muchos sitios. Igual que <posicion> y <posicion1>; mejor que sean algo como <posicion_maximo> y <posicion_minimo>.
  • Sentencias innecesarias
    A partir de la línea 60, cuando quieres mostrar los positivos y los negativos. Recorres los vectores/arrays/arreglos :xD donde has guardado por un lado los positivos y por otro los negativos. No tienes que comprobar otra vez que el valor que hay guardado sea positivo o negativo respectivamente. Además usa dos contadores para saber cuántos positivos hay (esos serán los que tienes que recorrer cuando los quieras mostrar) y otro igual pero para los negativos. (Si tienes 3 positivos y 2 negativos, no muestres 5 posiciones porque las últimas contendrán basura o 0).

    Creo que no me dejo nada más. Suerte y ya me comentarás lo que consigas avanzar... O lo que no. :-X :-X
#624
Para la próxima el código del programa entre etiquetas de Código GeSHi (puedes seleccionar el lenguaje de programación apropiado en un desplegable que hay encima del cuadro de texto)


Ese código tiene un problema. Si introduces todos los elementos positivos, el mínimo va a ser incorrecto y si introduces todos los elementos negativos, el máximo va a ser incorrecto... :rolleyes: :rolleyes:
Además tienes una variable que parece que es para contar los 0, pero no la estás usando...

Citar
1- NO SE POR QUE CUANDO ME IMPRIME LA POSICION EN LA QUE ESTA EL NUMERO MAYOR Y EL MENOR ME DA LA MISMA POSICION DEBERIA SER DIFERENTE
La posición es la misma porque lo estás guardando en la misma variable <posicion>... Por eso se sobreescribe la primera asignación que es la posición del número mayor y se guarda la última asignación que haces que es la posición del menor número del array.

Citar
2- COMO PUEDO CONTAR LA CANTIDAD DE NUMERO POSITIVOS QUE SON Y CUALES SON, YA CONSIGO QUE ME HAGA LA SUMA DE LOS NUMEROS POSITIVOS Y NEGATIVOS PERO NO CONSIGO SABER COMO IMPRIMIR CUALES SON Y CUANTOS SON
Para contar los números positivos y los negativos, crea dos variables <cantidad_positivos> y <cantidad_negativos> y como ya tienes una condición para detectar cuándo un número es positivo o negativo, sólo tienes que incrementar la variable correspondiente en cada caso.
Para saber cuáles son puedes:
  • Obtenerlo al momento que recorres el array.

    Numeros positivos:
    Desde i := 0 hasta elementos-1
        si v[i] > 0
            mostrar v[i]
        fin si

    Numeros negativos:
    Desde i := 0 hasta elementos-1
        si v[i] < 0
            mostrar v[i]
        fin si

    También puedes recorrer el array una sola vez y mostrar cada elemento en una línea seguido de "positivo" o "negativo" según el caso.

  • Guardarlos en otro array auxiliar

    Desde i := 0 hasta elementos-1
        si v[i] > 0
            guardar v[i] en array_positivos
        sino
            guardar v[i] en array_negativos
        fin si


  • Guardar los índices en otro array auxiliar. En este caso es un poco lío pero si trabajas con objetos más grandes es una forma de ahorrar espacio.

    Desde i := 0 hasta elementos-1
        si v[i] > 0
            guardar i en indices positivos
        sino
            guardar i en indices negativos
        fin si
#625
Puede ser porque tengas abiertas dos ventanas donde estés ejecutando el mismo programa.
Si no es eso, coloca tú código porque no somos adivinos. Suerte :-X
#626
Coloca el resto de tú código para que pueda ver el problema
#627
Imagino que te refieres a usando memoria dinámica. En ese caso el proceso es el siguiente, tanto en una función con parámetros como en el <main>:
Código (cpp) [Seleccionar]

int **matriz;
int filas = 4, columnas = 4;

matriz = new int* [filas]; // reservamos memoria en el puntero para tantos punteros como filas tenga la matriz
for(int i = 0; i < filas; ++i) // por cada fila
    matriz[i] = new int [columnas]; // reservamos espacio para x columnas

También se podría hacer al revés y crear punteros para cada columna y luego reservar filas pero se suele hacer así.
No olvides luego liberar toda la memoria dinámica que hemos reservado... Suerte :-X
#628
Cita de: FalKorXXI en 31 Marzo 2019, 13:40 PM
Hola. Y si pruebas a hacerlo así?

#include <iostream>
using namespace std;

void suma_pos_pares(int n, int& suma, int& contador){
    while(n != 0){
      if(contador%2 == 0)suma += n%10;
      n /= 10;
      ++contador;
    }
}

int main(){
    int n;
    int suma = 0;
    int contador = 1;
    cin >> n;
    suma_pos_pares(n, suma, contador);
    cout << suma << endl;
}


:D

Coloca tu código entre etiquetas de código GeSHi :-X

Es una forma de simplificarlo pero en la función <suma_pos_pares()>, el último parámetro creo que sobra completamente (ya que además hacer uso de el puede dar a errores al ser pasado por referencia) y el segundo parámetro también lo quitaría y que devuelva la suma la propia función. Imagina que usas la función esa 3 veces y olvidas poner el contador a 1 y la suma a 0 antes de cada ejecución; la primera ejecución sería correcta pero las dos siguientes, no.
Además la idea del contador para coger solo las posiciones pares funciona bien cuando lo piensas pero complica un poco más el código.

Para sumar las posiciones pares de un número, ¿qué necesitas saber? El número. Suficiente. Entonces podemos dejarlo así:
Código (cpp) [Seleccionar]

int sumarPosicionesPares(int numero){
    int suma = 0;
    while(numero != 0){
        numero /= 10;
        suma += numero % 10;
        numero /= 10;
    }
    return suma;
}
#629
Cita de: Loretz en 31 Marzo 2019, 01:20 AM
En tu línea 6 tienes declarado el puntero p, pero sin inicializar, no apunta a NULL
Tienes razón en esto. Fue fallo mío que pensé en asignarle NULL pero lo olvidé al estar pensando en el resto de la explicación :xD
Además no conocía la diferencia entre <NULL> y <nullptr> así que gracias también por ello.

Cita de: NextByte en 31 Marzo 2019, 05:01 AM
¿ Por qué se dice que la macro NULL no es recomendada en C++ ?, he visto varias fuentes que afirman eso pero no logro entender el por que. Sé que la macro 'NULL' viene desde C y que representa el numero entero 0 y que 'nullptr' fue agregado en C++11 pero ¿ qué problemas puede conllevar el usar la macro 'NULL'. ?
Por lo que he leído yo es porque <NULL> equivale a un 0 de tipo <int>; mientras que <nullptr> equivale a 0 también (si muestras el valor puedes verlo) siempre sigue siendo de tipo puntero, como dice @Loretz es de tipo <nullptr_t>. Entonces se evita el uso de <NULL> porque puede dar errores de ambigüedad al cambiar el tipo de dato.

Cita de: Loretz en 31 Marzo 2019, 01:20 AM
Como &p[0] y &p[1] son las direcciones consecutivas en memoria capaces de guardar sendos int(s), deben diferir en sizof(int*), ni más ni menos.
Es cierto que sus posiciones de memoria deben diferir en el tamaño del tipo de dato que puede almacenar. Pero como comenté, uso posiciones de memoria consecutivas y simples ya que lo que quería que se entendiese era ver de qué posiciones de memoria estamos hablando en cada momento.

Gracias por la respuesta ya que me diste la idea de probar el mismo programa para ver las posiciones de memoria que se utilizan. He añadido otra función para que se vea mejor el paso de un puntero por valor y por referencia.
Código (cpp) [Seleccionar]

int main(){
int *p = nullptr;
cout << "p esta en " << &p << " y su contenido es " << p << endl;
reservarMemoria(p,2);
p[0] = 1;
cout << "p[0] esta en " << &p[0] << " y su contenido es " << p[0] << endl;
p[1] = 2;
cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
anular(p,1);
// cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
}

void reservarMemoria(int *&v, int size){
cout << "FUNCION RESERVAR MEMORIA (puntero por referencia)" << endl;
cout << "v esta en " << &v << " y su contenido es " << v << endl;
v = new int [size];
}

void anular(int *v, int pos){
cout << "FUNCION ANULAR (puntero por valor)" << endl;
cout << "v esta en " << &v << " y su contenido es " << v << endl;
v[pos] = 0;
}


Al ejecutarlo obtenemos la siguiente salida (las posiciones de memoria depende de cada ejecución) donde podemos observar que coinciden los valores que comenté en mi anteior explicación:

p esta en 0x7fff4ce5ed50 y su contenido es 0
FUNCION RESERVAR MEMORIA (puntero por referencia)
v esta en 0x7fff4ce5ed50 y su contenido es 0
p[0] esta en 0x5650660fe280 y su contenido es 1
p[1] esta en 0x5650660fe284 y su contenido es 2
FUNCION ANULAR (puntero por valor)
v esta en 0x7fff4ce5ed38 y su contenido es 0x5650660fe280

En la función <reservarMemoria()> como se pasa el puntero por referencia se ve que la dirección de memoria de <v> (&v) es la misma que la de <p> (&p). Sin embargo en la función <anular()> como se pasa el puntero por valor, la dirección de memoria de <v> (&v) es distinta  a la de <p> (&p) aunque el valor que guardan que es la dirección de memoria de <p[0]> (&p[0]) en ambos casos, sí es la misma.
#630
Algo tan tonto como lo siguiente:

numero = 1234
numero(1234) >= 0? Si
    ultima_cifra = 4
    numero = 123
    ultima_cifra = 3
    suma += ultima_cifra // 3
    numero = 12
numero(12) >= 0? Si
    ultima_cifra = 2
    numero = 1
    ultima_cifra = 1
    suma += ultima_cifra // 4
    numero = 0
numero(0) >= 0? Si
    ultima_cifra = 0
    numero = 0
    ultima_cifra = 0
    suma += ultima_cifra // 4
    numero = 0
numero(0) >= 0? Si...


Creo que ya te has dado cuenta del problema no?? :rolleyes: