It is the same with pointers. All variables in C are passed by value, even pointers.

You copy the address stored in the pointer outside the function, into its parameter.

But you can use that address to reference a variable which can be allocated anywhere. So in the following code:

int j = 0;
incVar(&j);

incVar receives by-copy the address of j. But it can use that address to read or modify j (in)directly.

Ok I think I understand your problem.

You're trying to store the address number in baseAddr0, am I right? (not sure the reasons but this is the only thing I came up with).

The reason that a 0x500000 is showing as a 0 is because a uint8_t has not enough bits to represent an address and so it's "culling it down" to only 1 byte (therefore showing a 0).

Change the baseAddr to a uint32_t and voila, everything works.

Anyways, the reason the other posters are telling you to use a pointer to pointer is because what you seem to be doing is weird, unless you're planning on using the address for something special such as displaying it or using as an offset, perhaps?

p.s.: you're also going to need to change this line

*baseAddr=(uint32_t)sharedMemory;

edit: your code should look like this to get what you want:

    /* Window size in bytes. */
static  uint32_t size = 0;
    /* Window address. */
static  uint32_t address = 0;
    /* Memory Base Address */   
static uint8_t *sharedMemory=NULL;

sharedMemory = memalign(size, size);

void rioShardMemoryWindowGet (uint32_t *baseAddr,uint32_t *memorySize,uint32_t     *windowAddress  )
{
    *baseAddr=(uint32_t)sharedMemory;
    printf("sharedMemory: #%x",sharedMemory);
    *memorySize=size;
    *windowAddress=address;
}
rioShardMemoryWindowGet(&baseAddr0, &baseSize, &(Addrs.virtualBaseAddr));
printf("baseAddr0 : #%x",baseAddr0);

The reason why you NEED an uint32 to store the numeric address is because addresses are 32 bits, and that's the reason why you see a 0 using an 8 bit value, because 0x500000 maps to 0x00 to a byte

I think your issue is not with references / copy by value (you are already copying by value). It seems to me like you messed up on network / host byte order.

The sa_addr field of struct in_addr is in network byte order; when you copy that to network_addr and last_addr, you should convert it to host byte order, since you'll be doing shifting and other manipulations.

Furthermore, for some reason the code assumes that netmask is in network byte order, whereas in fact it is in host byte order. Things do not add up.

Just stick to host byte order and everything should work.

Change this line:

network_addr = last_addr = addr.s_addr;

To:

network_addr = last_addr = ntohl(addr.s_addr);

And delete this line:

netmask = ntohl(netmask);

You probably want to add return network_addr; in the end and possibly change the return type to uint32_t.

If you have an array declared like

char* names[9];

then the valid range of indices for this array is [0, 9) .

So these statements

names[9] =  (char *) malloc(4 * sizeof(char*));
strcpy(names[9],"gib");

access the non-existent element of the array with invalid index 9.

This loop

for (i = 0; i < 10; i++) {
    free(names[i]);
} 

is also incorrect by the same reason.

Do not us magic numbers like 9 0r 10. Use named constants as for example

enum { N = 9 };
char* names[N];

//...

for (i = 0; i < N; i++) {
    free(names[i]);
} 

And there is no sense to declare the array names as a global variable. You could declare it in main.

Though the allocated memory

names[0] =  (char *) malloc(4 * sizeof(char*));

can accommodate a string of four characters

strcpy(names[0],"foo");

nevertheless such an allocation only confuses readers of the code. Instead write in this an other similar statements

names[0] =  (char *) malloc(4 * sizeof(char));
                                       ^^^^^

or just

names[0] =  (char *) malloc( 4 );

Th function diddle the second parameter has the type char *

void diddle(char *names[], char *name) {

but in the function call

diddle(&names[0],&name);

there is used expression &name of the type char **.

As a result this statement

strcpy(name,names[j]);

invokes undefined behavior. Even if an passed expression had correct type

diddle(&names[0],&name);

nevertheless the function again had undefined behavior because the passed pointer is a null pointer. So you may not use strcpy with a null pointer.

Instead of the null pointer

char *name = NULL;

you could use a character array like

char name[4];

The moment you do bb = first;, bb and first are pointing to the same location of memory. first->a = 55; first->b = 55; first->c = 89; will change the values for a, b, and c in that location. The original value of first, is still lingering in memory but no way to access it anymore.

I think what you may want to do is *bb = *first;.

your first example will reserve memory on the stack for the variable copy. it will then copy the content of now to the new memory-location, and finally have next point to that memory location.

tm copy = *now;
tm* next = ©

the second example will not reserve any new memory; instead it will simply assign next the address (&) of the object now points to (*).

tm* next = &(*now);

the reason they are different, is that C never does any "automagic" memory allocation. you get what you ask for: if you ask for memory for a variable (as in the first example) you get it; if you don't ask for it, you don't get it.

so the difference between the two examples is really that declaring a variable (tm copy) is asking for memory.

You want to use %p to print a pointer. From the spec:

p The argument shall be a pointer to void. The value of the pointer is converted to a sequence of printing characters, in an implementation-defined manner.

And don't forget the cast, e.g.

printf("%p\n",(void*)&a);

You should use *variable to refer to what a pointer points to:

*x = 5;
*y = 5;

What you are currently doing is to set the pointer to address 5. You may get away with crappy old compilers, but a good compiler will detect a type mismatch in assigning an int to an int* variable and will not let you do it without an explicit cast.

Given any variable in C, you can get its address using the "address-of" operator &:

int x;
int* addressOfX = &x;

You can print out addresses using the %p specifier in printf:

printf("%p\n", &x); // Print address of x

To access individual bits of an integer value, you can use the bitwise shifting operators, along with bitwise AND, to shift the bit you want to the proper position and then to mask out the other bits. For example, to get the 5th bit of x, you can write

int x;
int fifthBit = (x >> 4) & 0x1;

This shifts down the number 4 bits, leaving the fifth bit in the LSB spot. ANDing this value with 1 (which has a 1 bit in the lowest spot and 0 bits everywhere else) masks out the other bits and returns the value. For example:

int x = 31; // 11111
prtinf("%d\n", (x >> 4) & 0x1); // Prints 1

void* memAddr = (void*)0xAABBCCDD; //put your memory address here
printf("int value at memory address %p is %i", memAddr, *((int*)memAddr));

You'll probably find that examining arbitrary memory addresses will just cause a crash.