Introdusco, Eh, eh, enverdad... ¿tanto cuesta escribir mínimamente bien?


Pues es justo lo que necesitas... con un par de cambios lo tienes hecho. En vez de separar por unidades, decenas y centenas, lo modificas para que separe por grupos de miles... y después juntas los grupos poniendo una coma entre medias. Esto último lo puedes conseguir usando strcat, por poner un ejemplo.

Por otro lado, sería conveniente que te hicieses con un buen libro de C. Si no te agrada esa vía siempre puedes seguir alguno de los muy buenos tutoriales de C que hay repartidos por Internet. Eso sí, buscar la solución concreta a lo que estás buscando no te va a ayudar a aprender a programar.

Un saludo.

Si la arquitectura es de 64 bits, entonces 64 bits es la unidad mínima de datos, luego lo normal es que la memoria consumida por cualquier programa sea múltiplo de 64 bits

Tu te refieres a esto, no?

void modulo( int n1, int n2 );
 
int main( )
{
  tipo t;
  modulo( t.n1, t.n2 );
}

Un saludo.

Utilizo reinterpret_cast porque detesto los cast a la usanza de C "int valor = (int)X;" y la conversión entre los dos tipos no tiene por qué ser compatible. En este caso, con reinterpret_cast le estoy diciendo al compilador algo del estilo "tranquilo que se lo que me hago, esta conversión es legal aunque no lo parezca".

remove_pointer es un template de type_trait y lo que hace es eliminar el puntero de la declaración del tipo. sizeof( T* ) va a devolver, normalmente, 4, ya que un puntero ocupa 4 bytes, sin embargo yo quiero calcular sizeof( T ). Y para hacer este último cálculo necesito eliminar el puntero de la declaración.

En cuanto al segundo byte, puede ser alineamiento provocado por tu compilador. Piensa que en una arquitectura de 32 bits, el procesador optimiza para que los datos entren en estos 32 bits, que es el tamaño normal con el que trabaja... si tu usas únicamente 24 bits, el compilador puede decidir desperdiciar los otros 8 para que el alineamiento sea perfecto.

No es sencillo comparar ambos lenguajes, yo he tenido que usar .NET para varios proyectos y la verdad es que me ha gustado bastante... de hecho me ha gustado más que Java.

Pero vamos, que no me apetece crear una nueva disputa como las que se forman entre pro-android y pro-iphone o pro-windows y pro-linux o pro-X y pro-Y.

Cada uno que use el lenguaje que más le guste que esa variedad nos da de comer a todos.

Por otro lado, este tipo de discusiones sobre si X es mejor que Y ya cansan.

Pues qué quieres que te diga... entre .net y Java, elijo la primera opción casi con los ojos cerrados.

¿Algo así?

#include <iostream>
 
class A
{
    int a;
    int b;
 
  public:
 
    A( )
      : a( 1 ), b( 2 )
    { }
};
 
void Imprime( void* ptr, size_t size )
{
  char* charPtr = static_cast< char* >( ptr );
 
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
int main()
{
  A a;
 
  Imprime( &a, sizeof( a ) );
}

---

Editado:

Después de pensarlo con un pelín más de tranquilidad... no hace falta pasar el size... basta con usar un template. Eso sí, debidamente especializado para poder manejar tanto punteros como referencias

#include <iostream>
#include <type_traits>
 
class A
{
    int a;
    int b;
 
  public:
 
    A( )
      : a( 1 ), b( 2 )
    { }
};
 
template< typename T >
typename std::enable_if< std::is_pointer< T >::value, void >::type Imprime( T ptr )
{
  std::cout << "Pointer version: ";
  char* charPtr = reinterpret_cast< char* >( ptr );
  size_t size = sizeof( typename std::remove_pointer< T >::type );
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
template< typename T >
typename std::enable_if< !std::is_pointer< T >::value, void >::type Imprime( const T& value )
{
  std::cout << "Reference version: ";
  const char* charPtr = reinterpret_cast< const char* >( &value );
  size_t size = sizeof( T );
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
int main()
{
  A a;
 
  Imprime( &a );
  std::cout << std::endl;
  Imprime( a );
}

Pues si pierdes dos minutos en revisar el código que he puesto en la respuesta anterior, te darás cuenta de que puedes añadir el número de elementos que te de la gana.

Si no quieres crear un array, siempre puedes crear una lista enlazada... aunque según lo que has puesto en el último mensaje me parece innecesario.

Te sigues explicando como un libro cerrado.

A ver, si tu idea es crear un número X de elementos enteros puedes usar malloc:

typedef struct
{
  int numElems;
  int* data;
} Array;
 
int main( )
{
  Array array;
  scanf( "%d", &array.numElems );
 
  array.data = (int*)malloc( array.numElems * sizeof( int ) );
 
  int i;
  for( i=0; i<array.numElems; i++ )
    array.data[ i ] = i * 2 + 5;
 
  for( i=0; i<array.numElems; i++ )
    printf( "[%d] -> %d\n", i, array.data[ i ] );
 
  free( array.data );
}

Tu pregunta es un poco escueta.

¿Hay algún límite a esa configuración? Piénsatelo bien, libertad total suele implicar más cantidad de código y muchas veces no es algo realizable.

¿Cómo elige el usuario qué configuración quiere?

¿Qué uso se le quiere dar después a esa configuración?