Mensajes

Muy bien, vamos por partes. El problema que tienes es el siguiente: tienes una función para saber si un número es perfecto, abundante o defectivo y luego tienes que usar esa misma función para identificar los números abundantes dentro de un rango.
La solución es muy simple y lo vas a ver enseguida. Tu función <Perfecto()> devuelve un <int> pero en la función le haces un <return 0> por lo que siempre devuelve 0. Eso no tiene mucha utilidad. Además acabo de ver que esa función <Perfecto()> hace demasiadas cosas. A ver qué te parece mi propuesta:
Creas una función que sea <int Perfecto(int a)> que devuelve 0 si el a es perfecto, 1 si es abundante y -1 si es defectivo. Quitando todos los <cout> de la función y el bucle.
Entonces en el <main> es algo tan simple como esto:

Código (cpp) [Seleccionar] Expandir


for(int i = extremo_inferior; i <= extremo_superior; ++i) // la condicion con < o <= es decision tuya
    if(Perfecto(i) == 1)
        cout << "El numero " << i << " es abundate" << endl;
    else if(Perfecto(i) == 0)
        cout << "El numero " << i << " es perfecto" << endl;
    else // si no es 1 ni 0 no hace falta otra condicion, tiene que ser -1
        cout << "El numero " << i << " es defectivo" << endl;
Y esto lo puedes usar para calcular tanto los que son abundantes como los perfectos como los defectivos; solo tienes que modificar la condición con {-1, 0, 1}.
En casos que la "respuesta" de una función sea "sí/no" puedes retornar un <bool> y la idea es la misma. Usa los retornos de las funciones de forma que aporten información, para no aportar nada mejor usar una función de tipo <void>.
Además te recomiendo no usar variables globales a no ser que sean constantes globales en algunos casos.
De eso se trata una función es como encapsular una funcionalidad que luego puedas usar más veces. Creas una función que calcule algo de un número (normalmente evitando <cout>) y luego cada vez que la quieras usar la puedes acoplar a un <cout>, a un bucle, a una condición, etc.

Respecto al tema de <conio.h>, ciertamente es una librería no estándar por lo que todos los compiladores no pueden usarla por defectos y entonces puede dar errores según con que compilador lo compiles. El uso más frecuente de esa librería es <getch()> para hacer una pausa y es una mejora a utilizar <system("pause")> que usa más recursos del sistema para una tarea tan tonta, pero se puede mejorar más.
La solución es usar <cin.get()> (en <iostream> de C++) o <getchar()> (en <stdio.h> en C). Ambas hacen lo mismo y evitas usar librerías no estándar además de que son funciones que vienen en la librería más común de cada lenguaje, tanto de C como de C++.

Adjunta el código para poder ayudarte mejor.

EDITO: Claramente hay un error en tu código, pero el compilador lo advierte como un Warning por eso que sí compila. A la función <scanf()> le tienes que pasar la dirección de memoria de la variable, no su nombre.

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>
int main(){
    int n1=0,n2=0,suma=0; // no es necesario inicializarlas
    printf("ingrese un numero: ");
    scanf("%d", &n1); // te faltaba el &
    printf("ingrese otro numero: ");
    scanf("%d", &n2); // el & otra vez
    suma=n1+n2;
    printf("la suma es %d",suma);
    system("pause"); // mejor getchar();
    return 0;
}
Además de eso te recomiendo sustituir <system("pause")> por <getchar()>, el fin es el mismo y evitas una llamada al sistema que requiere más recursos que la alternativa que te he comentado, además que así no necesitas usar la librería <stdlib.h>

Si conoces tanto la secuencia como el valor d, necesitas tres bucles cada uno para ir avanzando por el array a un ritmo distinto e ir comprobando que la distancia entre los elementos a los que apunta cada índice de cada bucle es igual a d.
Te dejo que lo intentes programar y si tienes más dudas pon tus avances para ayudarte.

PD: Para la próxima pon tus códigos entre etiquetas de código GeSHi y hay un subforo de C/C++ por lo que puede que muevan este tema.
PD 2: Las funciones que no retornan nada (void) no necesitan llevar un <return> al final.

¿Cuál es el siguiente paso que debo de dar para seguir entendiendo como funcionan las computadoras, los lenguajes y cómo esta recibe y cumple órdenes?

Si como has dicho te interesa aprender cómo funcionan las computadoras internamente te recomendaría algunas cosillas como:

• Arquitectura de computadores: verás diferencias de los sistemas de 32/64 bits. La famosa arquitectura de Von Neumann (no estoy seguro de si se escribe así ), y algo muy importante, LA MEMORIA. Es fundamental saber cómo se cargan los programas en memoria, como se calculan direcciones de memoria (tipos de direccionamiento), etc.
  
• Ensamblador: me parece fundamental también saber algo de ensamblador. No hace falta que te aprendas todas las instrucciones y tal pero está bien conocer el punto intermedio entre nuestros programas en C/C++ por ejemplo y los 0 y 1 que usa la computadora. Se podría meter dentro de la arquitectura pero creo que se merece un punto a parte. Destacar la importancia de conocer cómo funciona la memoria aquí (registros).
  
• Sistemas operativos: los sistemas que han existido y existen. Los avances que han ido produciendo, las diferencias entre el modo kernel y el modo usuario (interesante esto úlimo aunque sea de un vistazo)
  
• Lenguajes de programación: aquí tienes una inmensa variedad para elegir, desde robustos C/C++/Java hasta modernos y sencillos Python/Ruby. Yo te recomendaría C/C++ primero porque fueron mis inicios y siguen siendo mis favoritos a día de hoy pero sobre todo porque trabajan un poco a más bajo nivel que Python por ejemplo. En C/C++ puedes trabajar más directamente con la memoria lo que te ayudará de forma práctica a entender toda la teoría que te habrás leído y releído de lo comentado más arriba.
  
  Creo que poco más que decir. Yo después de mis años de carrera en Ingeniería Informática te diría que esos son los fundamentos y lo que se me viene a la mente cuando pienso en el funcionamiento de los computadores.
  Suerte con tus proyectos

En caso de que el valor sea 0 ambos coinciden como es el caso de tu codigo si el usuario del ejecutable introduce "hola"

Eso está claro, el problema es que si intentas guardar la cadena que el usuario introduce en <cadenados> cuando no se ha reservado memoria para ello, se genera un error en tiempo de ejecución por lo que no se producen las salidas que deberían.
En mi caso al menos me genera una segmentation fault aunque me suena que en ocasiones en C se permitía escribir en espacios de memoria que no habían sido reservados si estos espacios no superaban los límites de memoria del programa. De todas formas sigue sin ser correcto...

No sé cómo te funcionaría pero a mí no me funciona. Sale un error por no tener memoria para <cadenados>.
Siempre que estés escribiendo en <cadenados> tiene que darte ese error (violación de segmento / segmentation fault). Otra cosa es si quitas también la parte en la que pides introducir "hola" en <cadenados>.

PD: No uses la librería <conio.h>, no es una librería estándar.

Buenas, lo primero de todo si puedes poner el código anterior entre etiquetas de código GeSHi (encima del cuadro de texto hay un desplegable que pone "Código GeSHi" donde puede seleccionar el lenguaje de programación correspondiente).

Tu problema no está en la línea que has comentado, esa sentencia es correcta. El problema lo tiene <cadenados>, te comento.
Imaginemos la memoria como cajitas, en cada una cabe un valor. Por ejemplo:

Código (c) [Seleccionar] Expandir


char x = 'a'; // seria una cajita que guarda el contenido de <x> o sea, la 'a'.
Un array/arreglo son un conjunto de cajitas; en las que en cada una de ellas, se guarda un valor, por ejemplo:

Código (c) [Seleccionar] Expandir


char arregloDeChar[SIZE]; //serian un numero de cajitas igual al valor SIZE y en cada una cabe un <char>
Muchas veces se confunde un array con un puntero, pero un puntero únicamente es una cajita que en vez de guardar un dato directamente, guarda la dirección de memoria de otro dato, por ejemplo:

Código (c) [Seleccionar] Expandir


char x = 'a'; // supongamos que la direccion de x es 0x1 entonces en la posicion de memoria 0x1 se almacena 'a' (dicho de forma simple)
char *px = &x; // aqui creamos otra cajita para px que almacena la direccion de x. Imaginemos que px se encuentra en 0x2, entonces en 0x2 se guarda 0x1.

La confusión entre punteros y arrays se debe a lo siguiente:

Código (c) [Seleccionar] Expandir


char array[10] = {'a', 'b', 'c'};
// array[0] es un dato de tipo char, array[0] = 'a'
// array[1] es un dato de tipo char, array[1] = 'b'
// array[2] es un dato de tipo char, array[2] = 'c'
// array es un puntero a array[0]
Entonces cuando se trabaja con memoria dinámica (cosa que si estás empezando dudo que conozcas) lo que se hace es declarar un puntero y luego a ese puntero se le reserva memoria para que pase de tener 1 cajita de memoria a tener más. Si trabajas con memoria dinámica lo que debes usar son arrays estáticos, es decir, con los corchetes como he hecho yo arriba.
Aquí es donde aparece tu problema. Estás guardando una cadena mediante la función <gets()> (la cual te recomiendo que cambies por <fgets()>, no se recomienda usar <gets()> porque es menos segura) al puntero <cadenados>, pero <cadenados> solo tiene 1 cajita para un caracter.

Y puede que te preguntes "por qué con <cadenados> tengo ese problema y con <cadenauno> y <cadenatres> no?"
Verás, al poner por ejemplo:

Código (c) [Seleccionar] Expandir


char *cadenauno = "hola";
Lo que sucede es que al cargar el programa en memoria para ser ejecutado hay un "array" (entiéndase así) en el que el programa tiene guardado "hola" para poder asignarlo a <cadenauno>. Como ese "hola" ya está guardado en una posición de memoria, el programa lo único que hace es guardar en <cadenauno> la dirección de memoria en la que está guardado "hola" (la dirección en la que comienza "hola").
Es por esto que <cadenauno> y <cadenatres> no dan problemas. Porque la cadena de caracteres "hola" ya existe en memoria. Sin embargo, <cadenados> como la introduce el usuario por teclado, no existe en memoria antes del tiempo de ejecución.

Solución: Declarar un array. Y si luego quieres usar otro puntero pues lo creas y haces que apunte al comienzo del array.

Código (c) [Seleccionar] Expandir


#define SIZE 100 // longitud suficiente para que quepa lo que queremos guardar
char cadena2Array[SIZE];
printf("Introduce el valor de cadena2: ");
fgets(cadena2Array, SIZE, stdin); //  mas seguro que gets() porque se asegura de no pasarse del limite SIZE
printf("El valor de cadena2Array es: %s", cadena2Array);

// si quieres otro puntero
char *cadena2Puntero = cadena2Array;
printf("El valor de cadena2Puntero es: %s", cadena2Puntero); // Misma salida ya que apunta al mismo sitio

Te dejo AQUÍ un enlace a otro tema reciente en el que se tratan también estos temas y tienen algunas explicaciones más completas.
Espero que te sirva.
Suerte

No entiendo lo que pides. Que te digamos un problema con esas características para tú resolverlo (lo cual puedes encontrar infinidad de ellos en cualquier sitio o puedes inventar uno propio) o que te demos un problema con esas características resuelto (lo cual está en contra de las normas del foro de hacer tareas).
Tanto en un caso como en otro, eres tú quien debe poner de su parte.

Diría que sí, tienes que ir pasando por todas las palabras mediante una variable "vertedero" (al final se le va a quedar ese nombre )
Porque para trabajar con ficheros de acceso aleatorio tienes que saber moverte en un fichero binario calculando los Bytes por los que quieres pasar.Te recomiendo usar acceso secuencial mejor.

Ese código se puede optimizar un poco. Te dejo aquí un código que guarda cada dígito en una posición del array.
Como estamos usando números enteros, no hace falta restarle la última cifra al número ya que el operador de división / realiza una división entre enteros por lo que obvia los decimales.
Además es recomendable que uses nombres de variables que expliquen mejor su uso.

Código (c) [Seleccionar] Expandir


int main(){
    int digitos[MAX_CIFRAS] = {0};
    long long numero;
    for(size_t i = MAX_CIFRAS-1; i >= 0; --i){
        digitos[i] = numero%10;
        numero /= 10;
    }
}