How the memory is mapped when fork is used?

Question

i am new to "fork()",I read everywhere that when a fork() is called an exact copy of current (calling) process is started.Now when I run following code ,there should be two different processes, having two different memory locations assigned to their vars and functions.

#include<stdio.h>
int i=10;
int pid;
 int main(){
  if((pid=fork())==0){
    i++;//somewhere I read that separate memory space for child is created when write is needed
    printf("parent address= %p\n",&i);// this should return the address from parent's memory space
  }else{
    i++;
    i++;
    printf("child address= %p\n",&i);// this should return the address of child's memory space 
  }
  wait(0);
  return(0);
 }

Why The output looks like:: 
child address::804a01c 
parent address::804a01c

Why both the address are the same for parent as well as child?

Answer 1

having two different memory locations assigned to their vars and functions.

Nope; Linux implements virtual memory, meaning that each process has its own complete address space. As a result, after a fork, both processes see the same addresses for their copies of in-memory objects.

(As an aside: VM also causes code to be shared between the process in physical memory, and all data will only be copied-on-write.)

Answer 2

Addresses are process-local. 804a01c in one process is not the same as 804a01c in another process.

Answer 3

Because of virtual memory: both address spaces look identical to the respective processes. The physical memory those are stored in is different. However that is, in practice, complicated by a memory optimization (implemented by most kernels) which maps the corresponding different virtual pages to the same physical pages until one of those processes writes to that page of memory, at which time the page is duplicated physically to another physical address (and the virtual page is remapped for the process).

There are many other complications as well: The most recognized is that the return value of fork() differs between processes, though that is usually a difference in a register value, not memory. However, open files, and some other resources can be marked un-inheritable, so there could be other differences—minor but sometimes useful.