What is the difference between these two?

Question

0.00/5 (No votes)

See more:

In the first case, segmentation fault error.
In the second case, output is 2.
In the first case as the array was declared in local function, once we move in to main function the array memmory gets destroyed.
But, In the second case why I am getting output and why there is no segmentation fault error?

What I have tried:

C++

#include<stdio.h>
int create()
{
    int a[3]={1,2,3};
    return a;
}
int main()
{
  int *c=create();
  printf("%d",c[1]);
  return 0;
}


// second case:

#include<stdio.h>
int create()
{
    int *p=(int*)malloc(sizeof(int)*3);
    p[0]=1;
    p[1]=2;
    p[3]=3;
    return p;
}
int main()
{
    int *c=create();
    printf("%d",c[1]);
    return 0;
}

Posted 5-May-21 21:40pm

_-_-_-me

Updated 6-May-21 5:17am

KarstenK

v2

Add a Solution

Comments

Richard MacCutchan 6-May-21 4:26am

In case 1 the array a is created on the stack within the create function. But when that function returns its stack is destroyed so the array no longer exists. So the address returned from the function is no longer valid.

_-_-_-me 6-May-21 8:24am

okay, thank you very much!

jeron1 6-May-21 10:02am

Also, this line

p[3]=3;

will produce non-determinant results, the largest index an array of size = 3, is 2.

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

CPallini · Accepted Answer · 2021-05-05T21:57:00

Quote:
But , In the second case why I am getting output and why there is no segmentation fault error ?

because, in the second case, you are returning the address of a dynamically allocated memory block which is only released ('destroyed') on request (calling the free function).
Note, your code is not robust, it should be:

C

#include<stdio.h>
int * create()
{
    int *p= (int*) malloc(sizeof(int)*3);
    if ( p )
    {
      p[0]=1;
      p[1]=2;
      p[3]=3;
    }
    return p;
}

int main()
{
    int *c = create();
    if ( c )
    {
      printf("%d",c[1]);
      free(c);
    }
    return 0;
}

OriginalGriff · Accepted Answer · 2021-05-05T22:31:00

There is a technical term for what your first code is doing: returning a dangling pointer[^]

When you create variables in a function, they are allocated on a small area of memory called the stack, which acts like a "stack of coins":
You call a function, and the address you cam from is "pushed" on the top of the stack.
The function then allocates memory and pushes that to the top of the stack.
The function runs, and used the variables
When you return, the function "pops" all the variables it stacked off again, then "pops" the return address off and goes back where it came from with that.

When you return a pointer to a local variable from teh function, the pointer is to memory that has been freed, and that will be used by the next function call. So the call to printf will corrupt memory that you pointed to and things ... start to go wrong in unpredictable ways ...

When you allocate memory using malloc, it doesn't come from the stack - it comes from a much, much larger area of memory called the heap and that isn't released until you explicitly call free and pass the pointer to it.
If you don't call free then your code probably won't crash for a long time - but it will start to "leak memory" because the heap while large is not infinite!

The size of the stack and the usage above also explains why you will get "out of memory" or "stack overflow" errors if you deliberately or accidentally start using direct or indirect recursion without adequate checks in place!

What is the difference between these two?

2 solutions

Solution 1

Solution 2

Add your solution here

Preview 0