How i can do that ?

then you can copy the number to the array like:
char_array[0] = number & 0x000000ff
char_array[1] = number & 0x0000ff00
char_array[2] = number & 0x00ff0000
char_array[3] = number & 0xff000000

Marius
--
<URL: http://home.ifi.uio.no/~mariube/ >

To answer your question:  the most straightforward and readable way is
to use the library routine memcpy(), with the following prototype and
header file:

#include <string.h>
void memcpy(void *dest, const void *src, size_t bytes);

Use it like this:

long my_long = 2354723;
unsigned char my_uchar_buffer[sizeof my_long] = {0};
memcpy(my_uchar_buffer, &my_long, sizeof my_long);

HTH,
Ryan.

    memcpy(buff, &foo, sizeof foo);

Of course, if you insist on copying 4 bytes, regardless of the actual
size of a long, you have to replace sizeof foo by the magical constant 4.

This may cause problems in the unlikely event that sizeof(long) < 4 on a
hosted implementation (on freestanding implementations you can't rely on
the existence of memcpy).

#include <stdio.h>
#include <string.h>
#include <limits.h>

int main(void)
{
     unsigned long ul = 037700066655ul;
     unsigned char c[sizeof ul];
     size_t i;
     memcpy(c, &ul, sizeof ul);
     printf("The unsigned long had %#lo (%#lx, %lu)\n", ul, ul, ul);
     printf("The chars are:\n");
     for (i = 0; i < sizeof ul; i++)
         printf("%2u: %#o (%#x, %u)\n", (unsigned) i, c[i], c[i], c[i]);
     return 0;

        mike

int main(void)
{
    size_t byte;
    long unsigned data;
    unsigned char array[sizeof data];

    data = 0x12345678;
    puts("\ndata = 0x12345678;\n");
    byte = sizeof data;
    while (byte--) {
        array[byte] = ((unsigned char*)&data)[byte];
    }
    printf("The lowest addressable byte of data, "
        "has a value of 0x%x\n",  array[0]);
    for (byte = 1; byte != sizeof data; ++byte) {
        printf("The   next addressable byte of data, "
            "has a value of 0x%x\n",  array[byte]);
    }
    return 0;

The technique works reliably and portably only for arrays of unsigned
char, which cannot have trap representations.