Mensajes

Primero, en el ciclo for donde muestras el contenido del arreglo estás accediendo a memoria fuera del arreglo. Un arreglo tiene los índices 0, 1, 2, ... hasta el tamaño que le hayas asignado - 1. Entonces, en el for estás accediendo al elemento '8' del arreglo, mientras que al elemento máximo que puedes acceder es al 7 (8 - 1).

Segundo, estás incrementando el count antes de tiempo. Esto lo digo porque nunca inicializas m_bin[0] (ya dijimos que accedemos al arreglo desde el elemento 0), pero sin embargo estás accediendo a m_bin[1], m_bin[2], ... Nunca llegas a cambiar el valor de m_bin[0].

Tercero, el for lo tienes que mostrar fuera del bucle while, porque si muestras el contenido del arreglo sin inicializar, lo que muestras es basura. Esa "basura" es memoria que antes había sido ocupada por otros programas/procesos. Por ejemplo, fijémonos en tu código:

Código (cpp) [Seleccionar] Expandir

while(n != 0){
  int m = n%2;
  n = n/2;
  n_bin[count]=m;
  for(int i=7;i!=0;i--){ // Corrige el i=8 por i=7
   cout << n_bin[i];
  }
  count++; // Mejor aquí
}

Si te fijas bien, ¿le has dado un valor a n_bin[7] inicialmente? No, porque inicialmente solo inicializas n_bin[0], pero no inicializas n_bin[1], etc... Entonces, tendrías que sacar el for fuera. Así, primero convertirías el valor a binario y luego mostrarías los resultados.

Código (cpp) [Seleccionar] Expandir

while(n != 0){
    int m = n%2;
    n = n/2;
    n_bin[count]=m;
    count++; // Mejor aquí
}

for(int i=7;i!=0;i--){ // Corrige el i=8 por i=7
    cout << n_bin[i];
}

Primero quiero aclarar una cosa: ya hay una función para calcular la longitud de una cadena xD. Se llama strlen y puedes usarla al incluir string.h.

Segundo, recomiendo no retornar cadenas declaradas en una función (para mas detalles, pregunta). Lo que yo haría es intercambiar los valores de la cadena original para obtener el resultado final. Es decir, haría esto:

Tenemos la cadena llamada "cadena" (así de original soy) que equivale a "Esto es una cadena"

Código (cpp) [Seleccionar] Expandir

char cadena[] = "Esto es una cadena";

Lo que hay que hacer es recorrer la mitad de la cadena:

Código (cpp) [Seleccionar] Expandir

int longitud_cadena = strlen(cadena);
int i = longitud_cadena / 2 - 1;
while(i >= 0)

Por último, intercambia los valores:

Código (cpp) [Seleccionar] Expandir

intercambiar_valores(cadena[i], cadena[longitd_cadena - i]); // Esta función me la he inventado. Tendrás que diseñar tu mismo una función que intercambie valores o puedes intercambiar los valores directamente dentro del while.

____________________________

Por si no se ha entendido, esto es lo que está sucediendo:

Memoria donde se almacena la cadena:

Código [Seleccionar] Expandir

'E' 's' 't' 'o' '_' 'e' 's' '_' 'u' 'n' 'a' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'

Entonces, lo que hacemos es:

Código [Seleccionar] Expandir

                                 *   *
'E' 's' 't' 'o' '_' 'e' 's' '_' 'u' 'n' 'a' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'
Intercambiamos los valores marcados por los asteriscos. Los asteriscos marcan la posición dada por la variable 'i' y por la operación 'longtud_cadena - i', es decir, '18/2 - 1' y '18 - 18 - 18/2 - 1' respectivamente:

Código [Seleccionar] Expandir

                                 *   *
'E' 's' 't' 'o' '_' 'e' 's' '_' 'n' 'u' 'a' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'

En el siguiente ciclo, la variable 'i' se decrementa en 1. Entonces, ahora 'i' vale 7 y la operación 'longitud_cadena - i' vale 18 - 7:

Código [Seleccionar] Expandir

                             *           *
'E' 's' 't' 'o' '_' 'e' 's' '_' 'n' 'u' 'a' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'
Intercambiamos los valores señalados por los asteriscos:

Código [Seleccionar] Expandir

                             *           *
'E' 's' 't' 'o' '_' 'e' 's' 'a' 'n' 'u' '_' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'

Seguimos decrementando 'i':

Código [Seleccionar] Expandir

                         *                   *
'E' 's' 't' 'o' '_' 'e' 's' 'a' 'n' 'u' '_' '_' 'c' 'a' 'd' 'e' 'n' 'a' '\0'
Intercambiamos...

Código [Seleccionar] Expandir

                         *                   *
'E' 's' 't' 'o' '_' 'e' '_' 'a' 'n' 'u' '_' 's' 'c' 'a' 'd' 'e' 'n' 'a' '\0'

Y así hasta que i sea 0 (después el while se detendrá por la condición)

Código [Seleccionar] Expandir

*                                                                   *
'E' 'n' 'e' 'd' 'a' 'c' '_' 'a' 'n' 'u' '_' 's' 'e' '_' 'o' 't' 's' 'a' '\0'
Y como siempre, intercambiamos:

Código [Seleccionar] Expandir

*                                                                   *
'a' 'n' 'e' 'd' 'a' 'c' '_' 'a' 'n' 'u' '_' 's' 'e' '_' 'o' 't' 's' 'E' '\0'

Al final, obtenemos la cadena "anedac  anuse otsE"

Si, pero el problema de encadenar ifs es que no quiero que las operaciones sigan XD. Me quedaré con la tercera forma, aunque resulte un poco tedioso...

Muchas gracias a tod@s por sus respuestas!

Comprendo... Pero, para que quede claro, escribir un programa como el que he planteado (el que tiene muchos return), en este caso, no estaría mal, ¿no? Gracias!

Nunca he dicho que se pudiera XDD He recordado lo que la pregunta pedía!

[general]

Es lo que digo, en C++ se puede hacer con las platillas, pero en C, en tu código, estás presuponiendo que son enteros, mientras que la pregunta pide una función general para sumar entre diferentes tipos

Eso me han comentado, por eso no lo he afirmado... En cualquier caso, creo que el problema reside a nivel de ensamblador, donde la instrucción return "trocea" el programa (sinceramente, no lo sé muy bien, y tampoco sé que puede tener de malo )

Hola, muy buenas. Haciendo un código me ha surgido una duda bastante importante a mi parecer. Según tengo entendido, una buena función es aquella que apenas tiene 'return'. Bien, pues yo quiero hacer una función con un diagrama de flujo como el siguiente:

Realizar Operación
Comprobar si ha salido bien
>> Ha salido mal
     Salir del programa
>> Ha salido bien
Realizar Operación 2º
>> Ha salido mal
     Salir del programa
>> Ha salido bien
Realizar Operación 3º
...
Y así sucesivamente hasta que todas las operaciones hayan terminado con éxito. Eso, en C++, sería algo así:

Código (cpp) [Seleccionar] Expandir

bool funcion() {
    Realizar_Operacion_1();
    if(Operacion_1_ha_tenido_exito() == false) {
        return false;
    }

    Realizar_Operacion_2();
    if(Operacion_2_ha_tenido_exito() == false) {
        return false;
    }
    Realizar_Operacion_3();
    ...

    return true;
}

Ahora bien, si tenemos en cuenta lo que dije al principio, este programa no sería el mejor porque tiene muchos saltos de línea 'return'. Entonces, otra forma de solucionarlo es así:

Código (cpp) [Seleccionar] Expandir

bool funcion() {
    Realizar_Operacion_1();
    if(Operacion_1_ha_tenido_exito() == false) {
        return false;
    } else {
        Realizar_Operacion_2();
        if(Operacion_2_ha_tenido_exito() == false) {
            return false;
        } else {
            Realizar_Operacion_3();
            ...
        }
    }

    return true;
}

Pero este código se hace muy "ancho" cuando hay muchas operaciones a comprobar.

Entonces, lo último que se me ha ocurrido es lo siguiente:

Código (cpp) [Seleccionar] Expandir

bool funcion() {
    bool error = false;
   
    Realizar_Operacion_1();
    if(Operacion_1_ha_tenido_exito() == false) {
        error = true;
    }

    if(error == false) {
        Realizar_Operacion_2();
        if(Operacion_2_ha_tenido_exito() == false) {
            error = true;
        }
    }

    if(error == false) {
        Realizar_Operacion_3();
        if(Operacion_3_ha_tenido_exito() == false) {
            error = true;
        }
    }
   
    ...

    return error;
}

Pero no lo veo muy bien, son muchos 'if' que no sé si son necesarios...

Me gustaría saber si saber de algún método mejor para realizar este tipo de diagramas de flujo... Gracias

¿Cómo sumaríais después los números? (Es lo que pide el que pregunta XD)

Lo único que tendrías que hacer es añadir un carácter de fin de cadena a las cadenas del nombre y del apellido. Por ejemplo, tenemos siguiente cadena:

Código (cpp) [Seleccionar] Expandir

char cadena[4] = {'H', 'o', 'l', 'a'};

En esta cadena no hay un carácter que delimite su fin (te invito a que pienses en lo contrario, pero ya te digo que no hay nada que indique el final de la cadena en el programa). Para ponerle un fin a esa cadena, tienes que añadir el carácter nulo donde sea el final de la cadena:

Código (cpp) [Seleccionar] Expandir

char cadena[5] = {'H', 'o', 'l', 'a', '\0'};

Como ves, ahora la cadena es una unidad más larga porque tiene un carácter que la delimita. Ese carácter, llamado carácter nulo, se escribe como has visto ( '\0' ). Equivale a un entero 0.

PISTA: ¡¡¡Puedes añadir el carácter nulo en el 'else'!!!