Puedes hacer algo asi:

typedef struct
{
    int edad;
    string nombre;
} persona;
 
persona* registrarPersonas( persona* datos, int n);
 
int main(void)
{
    persona datos[2];
    persona* info;
 
    info = registrarPersonas(datos, 2);
 
    for(int i = 0; i < 2; i++)
        cout << "Nombre: " << info[i].nombre << "\nEdad: "   << info[i].edad << endl;
 
    return 0;
}
persona* registrarPersonas( persona* datos, int n)
{
    for(int i = 0; i < n; i++)
    {
        cout << "Nombre: ";
        getline(cin, datos[i].nombre );
 
        cout << "Edad: ";
        cin >> datos[i].edad;
        cin.ignore();
    }
    return datos;
}
 

Un Saludo

Esto mas bien seria una pequeña modificación para obtener mayor eficiencia y rapidez :

for(B = 2; B <= E; B++)
{
    C = 2;
    while (C * C <= B  && B % C != 0) C++;
    if (C * C  > B)
        printf("%6d\n", B);
}

Y respecto a lo que intentas hacer podrías especificar exactamente como quieres imprimirlos

Saludos

Claro yo solo seguí la lógica de tu código asumiendo que el multiplicador seria no mas de un dígito para encarar operaciones del tipo que expones se tendría que hacer importantes modificaciones al código; quedaría un poco mas extenso y complejo

Un Saludo NOB2014

Inicializar j a 2 para ir almacenando el resultado en la ultima posición del array  e ir decrementandolo sucesivamente, te dejo el código con todas las correcciones en especial la parte de acarreo que no tomaba algunos casos :

int main(void)
{
    char a[] = "914", b[] = "3", mult[4];
    int i, j, result = 0, resto = 0, operUno = 0, operDos = 0;
 
    for(i = j = 2; i >= 0; i--, j--)
    {
        operUno = a[i] - '0', operDos = b[0] - '0';
        result = operUno * operDos + resto;
        if (result >= 10)
        {
            resto = result / 10;
            result -= resto * 10;
        }
        else
            resto = 0;
        mult[j] = result;
    }
    if (resto)
    {
        for( i = 3; i > 0; i--)
            mult[i] = mult[i - 1];
        mult[0] = resto;
    }
    for(i = 0; i < 4 ; i++)
        printf("%d", mult[i]);
 
    return 0;
}
 

Un saludo

El problema con el código del compañero es que de igual manera procesa los primos no validos (23, 29) y también mencionar el desbordamiento de enteros producido, he aquí un ejemplo que calcula los ocho números perfectos :

#include <math.h>
#include <stdio.h>
#include <limits.h>
 
typedef enum { FALSE = 0, TRUE = 1 } BOOL;
 
BOOL is_prime( int p )
{
    if( p == 2 ) return TRUE;
    else if( p <= 1 || p % 2 == 0 ) return FALSE;
    else
    {
        BOOL prime = TRUE;
        const int to = sqrt(p);
        int i;
        for(i = 3; i <= to; i+=2)
            if (!(prime = p % i))
                break;
        return prime;
    }
}
 
BOOL is_mersenne_prime( int p )
{
    if( p == 2 )
        return TRUE;
    else
    {
        long long unsigned m_p = ( 1U << p ) - 1;
        long long unsigned s = 4;
        int i;
        for (i = 3; i <= p; i++)
        {
            s = (s * s - 2) % m_p;
        }
        return s == 0;
    }
}
 
int main(int argc, char **argv)
{
    const int upb = log2l(ULLONG_MAX)/2;
    int p;
 
    for( p = 2; p <= upb; p++ )
    {
        if( is_prime(p) && is_mersenne_prime(p) )
            printf(" %llu\n", (long long unsigned)(1U << (p - 1)) * ((1U << p) - 1));
    }
    printf("\n");
 
    return 0;
}
 

Puedes comprobarlo aquí :

http://www.vaxasoftware.com/doc_edu/mat/numperfe_esp.pdf

Un saludo

Con el algoritmo que propuse por supuesto se obtienen esa secuencia de primos menos el 23 el cual no forma parte de la secuencia de números perfectos en ves debes incluir el tres. Estoy utilizando la prueba de Lucas-Lehmer :

http://es.wikipedia.org/wiki/Test_de_Lucas-Lehmer

Para descartar todos los primos no valido, por otra parte en la función es_primo en tu código tienes un pequeño error la condición del for debe quedar así

prueba*prueba <= numero

Debido a esto validaba el nueve como un primo

Para generar los cinco números perfectos conocidos (6, 28, 496, 8128, 33550336) con la formula de  Euclides es necesario trabajar con los primos de mersenne (2, 3, 5, 7, 13)  aquí un ejemplo :

#include <math.h>
#include <stdio.h>
#include <limits.h>
 
typedef enum { FALSE = 0, TRUE = 1 } BOOL;
 
BOOL is_prime( int p )
{
    if( p == 2 ) return TRUE;
    else if( p <= 1 || p % 2 == 0 ) return FALSE;
    else
    {
        BOOL prime = TRUE;
        const int to = sqrt(p);
        int i;
        for(i = 3; i <= to; i+=2)
            if (!(prime = p % i))break;
        return prime;
    }
}
 
BOOL is_mersenne_prime( int p )
{
    if( p == 2 )
        return TRUE;
    else
    {
        unsigned m_p = ( 1U << p ) - 1;
        unsigned s = 4;
        int i;
        for (i = 3; i <= p; i++)
            s = (s * s - 2) % m_p;
        return s == 0;
    }
}
 
int main(void)
{
    int p;
 
    for( p = 2; p <= 13; p += 1 )
        if( is_prime(p) && is_mersenne_prime(p) )
           numero_perfecto(p);
           /*printf("%d ", p);*/
    printf("\n");
 
    return 0;
}
 

Un Saludo

Aquí tienes un código bastante interesante, que a mi parecer es bastante rápido :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
char bits[65536];
 
typedef unsigned long ulong;
ulong primes[7000], n_primes;
 
typedef struct
{
    ulong p, e;
} prime_factor;
 
void sieve(void)
{
    int i, j;
    memset(bits, 1, 65536);
    bits[0] = bits[1] = 0;
    for (i = 0; i < 256; i++)
        if (bits[i])
            for (j = i * i; j < 65536; j += i)
                bits[j] = 0;
    for (i = j = 0; i < 65536; i++)
        if (bits[i]) primes[j++] = i;
 
    n_primes = j;
}
 
int get_prime_factors(ulong n, prime_factor *lst)
{
    ulong i, e, p;
    int len = 0;
 
    for (i = 0; i < n_primes; i++)
    {
        p = primes[i];
        if (p * p > n) break;
        for (e = 0; !(n % p); n /= p, e++);
        if (e)
        {
            lst[len].p = p;
            lst[len++].e = e;
        }
    }
    return n == 1 ? len : (lst[len].p = n, lst[len].e = 1, ++len);
}
 
int ulong_cmp(const void *a, const void *b)
{
    return *(const ulong*)a < *(const ulong*)b ? -1 : *(const ulong*)a > *(const ulong*)b;
}
 
int get_factors(ulong n, ulong *lst)
{
    int n_f, len, len2, i, j, k, p;
    prime_factor f[100];
 
    n_f = get_prime_factors(n, f);
 
    len2 = len = lst[0] = 1;
    for (i = 0; i < n_f; i++, len2 = len)
        for (j = 0, p = f[i].p; j < f[i].e; j++, p *= f[i].p)
            for (k = 0; k < len2; k++)
                lst[len++] = lst[k] * p;
 
    qsort(lst, len, sizeof(ulong), ulong_cmp);
    return len;
}
 
int main(void)
{
    int j;
    ulong fac[10000], n, sum;
 
    sieve();
 
    for (n = 2; n < 33550337; n++)
    {
        j = get_factors(n, fac) - 1;
        for (sum = 0; j && sum <= n; sum += fac[--j]);
           if (sum == n)
              printf("%lu\n", n);
    }
    return 0;
}
 

Fuente : http://rosettacode.org/wiki/Factors_of_an_integer#Prime_factoring

Solo le hice una pequeña modificación en el main para adaptarlo a tu propósito

Un Saludo

Haciendo uso de qsort podríamos ir ordenando sucesivamente los elementos generados, mas o menos así :

int comparar(const void * x, const void * y)
{
    return ( *(int*)x - *(int*)y );
}
 
void generar(void)
{
    int guardar[6], numero = 0;
    int i, hora = time(NULL);
 
    srand(hora);
 
    for (i = 0; i <= 6; i++)
    {
        numero = rand() % 46;
 
        guardar[i] = numero;
 
        qsort(guardar, i, sizeof(int), comparar);
    }
}
 

Un Saludo

Puedes generar la figura completa de la siguiente manera :

int i = -5, j = 0;
 
while(i <= 5)
{
     j = -5;
     while( j <= 5)
    {
         printf("%c", abs(i) <= abs(j) ? '*' : ' ');
         j++;
    }
     putchar('\n');
     i++;
}

Usando la función abs con la cual vamos dibujando las dos figuras juntas al mismo tiempo..

Un Saludo