Troubleshooting C Code: Segmentation Fault in GCC on Ubuntu

  • Thread starter Thread starter matiasmorant
  • Start date Start date
  • Tags Tags
    C code Code Error
AI Thread Summary
The discussion centers on two C code snippets that lead to runtime errors and unexpected behavior. The first code snippet compiles successfully but results in a "Segmentation fault" due to the use of an uninitialized pointer. The pointer 'a' is not allocated any memory before attempting to assign a value, leading to an attempt to access invalid memory.The second code snippet involves a swap function that does not perform as expected. The user anticipates that swapping two pointers would change their references, but it does not. The explanation clarifies that the pointers are passed by value, meaning the function operates on copies of the pointers rather than the original pointers themselves. To achieve the desired swap, the function needs to accept pointers to pointers, allowing modifications to the original pointers outside the function's scope. The corrected function signature and call are provided, demonstrating how to pass the addresses of the pointers to achieve the intended behavior.
matiasmorant
Messages
38
Reaction score
0
the following code

#include<stdio.h>
#include<stdlib.h>

int
main (int argc, char *argv[])
{
int* a;
*a=1;
return 0;
}

compiles ok, but throws "Segmentation fault (core dumped)" at runtime
why is that?

i'm working with gcc in ubuntu. I have been able to compile and run many c programs without any difficulties
 
Technology news on Phys.org
matiasmorant said:
the following code

#include<stdio.h>
#include<stdlib.h>

int
main (int argc, char *argv[])
{
int* a;
*a=1;
return 0;
}

compiles ok, but throws "Segmentation fault (core dumped)" at runtime
why is that?

i'm working with gcc in ubuntu. I have been able to compile and run many c programs without any difficulties

Hey matiasmorant and welcome to the forums.

The simple reason is that a is a pointer that has not been initialized and you are trying to set the contents of the memory of that location to something.

Because of this, you are trying to access memory in the wrong way and it crashes.

Before you work with pointers, you must realize that what you reference must be declared either on the stack or on the heap. Heap elements are created with malloc and other similar statements and are freed using free in C (in C++ it's new and delete).

Things declared on the stack are things like say 'int x = 0;' or 'char r[128];'

If you want to set say x in the above example you can create a pointer that points to this by saying int* xpointer = &x; *xpointer = 3; which will set the value of x to 3. If you want to use the heap then do int* xpointer = malloc(4); (Check to make sure xpointer is not 0 before doing the next part!). *xpointer = 3. This will set a heap variable. (Make sure you call free(xpointer); when you are finished).

Just out of curiosity, how long have you been learning? Is this your first time?
 
thanks a lot! it's great to receive such a quick response

I started learning programming about 10 months ago, I already finished the programming course, and I did plenty of programs with pointers, pointers to pointers, pointers to functions, etc. Then I started working with java and forgot some of the c language. Now, I was trying to learn openGL with java, but couldn't make jogl work, so i came back to c, where it works perfect up to now. That's my programming biography ;)

now, what about the following code? (i hope this will be the last question)

#include<stdio.h>
#include<stdlib.h>

void SWAP(double *f1, double *f2){
double *temp;
temp=f1;
f1=f2;
f2=temp;
printf("inside %f %f\n",*f1,*f2);
}

int
main (int argc, char *argv[])
{
double *f1, *f2;

f1=(double*)malloc(sizeof(double));
f2=(double*)malloc(sizeof(double));
*f1=1;
*f2=2;
printf("before %f %f\n",*f1,*f2);
SWAP(f1,f2);
printf("after %f %f\n",*f1,*f2);

return 0;
}

i expected the answer to be

before 1.000000 2.000000
inside 2.000000 1.000000
after 2.000000 1.000000

but it was

before 1.000000 2.000000
inside 2.000000 1.000000
after 1.000000 2.000000

why doesn't the swap function... swap?

(i need to swap the references and not the contents, since i will be working with matrices)

thanks in advance!
 
matiasmorant said:
thanks a lot! it's great to receive such a quick response

I started learning programming about 10 months ago, I already finished the programming course, and I did plenty of programs with pointers, pointers to pointers, pointers to functions, etc. Then I started working with java and forgot some of the c language. Now, I was trying to learn openGL with java, but couldn't make jogl work, so i came back to c, where it works perfect up to now. That's my programming biography ;)

now, what about the following code? (i hope this will be the last question)

#include<stdio.h>
#include<stdlib.h>

void SWAP(double *f1, double *f2){
double *temp;
temp=f1;
f1=f2;
f2=temp;
printf("inside %f %f\n",*f1,*f2);
}

int
main (int argc, char *argv[])
{
double *f1, *f2;

f1=(double*)malloc(sizeof(double));
f2=(double*)malloc(sizeof(double));
*f1=1;
*f2=2;
printf("before %f %f\n",*f1,*f2);
SWAP(f1,f2);
printf("after %f %f\n",*f1,*f2);

return 0;
}

i expected the answer to be

before 1.000000 2.000000
inside 2.000000 1.000000
after 2.000000 1.000000

but it was

before 1.000000 2.000000
inside 2.000000 1.000000
after 1.000000 2.000000

why doesn't the swap function... swap?

(i need to swap the references and not the contents, since i will be working with matrices)

thanks in advance!

The reason for this is because you are passing the pointers by value and not by reference.

Passing by value means that you give the values to the function more or less a kind of copy, whereas passing the values by reference passes the actual pointer to the object and allows you to modify either the actual corresponding pointer or object.

What you are actually doing is passing a copy of the pointer and just setting stuff inside the routine that has no effect on anything outside the scope of the function. This is why when you print the two variables, you get the swap inside the function but not outside.

What you need to do is pass a pointer to the pointer of the function and modify the pointer itself to change by reference *pointer where you pass double** pointertopointer. This will modify the actual pointer itself even outside the function and everything will act as expected.
 
You would need the code to look like this:

Code:
void SWAP(double **f1, double **f2){
    double *temp;
    temp=*f1;
    *f1=*f2;
    *f2=temp;
    printf("inside %f %f\n",**f1,**f2);
}

int main (int argc, char *argv[])
{
/* ... */
    SWAP(&f1, &f2);
/* ... */
}
 
Last edited:
thanks friend! that was the last question
 
Dear Peeps I have posted a few questions about programing on this sectio of the PF forum. I want to ask you veterans how you folks learn program in assembly and about computer architecture for the x86 family. In addition to finish learning C, I am also reading the book From bits to Gates to C and Beyond. In the book, it uses the mini LC3 assembly language. I also have books on assembly programming and computer architecture. The few famous ones i have are Computer Organization and...
I have a quick questions. I am going through a book on C programming on my own. Afterwards, I plan to go through something call data structures and algorithms on my own also in C. I also need to learn C++, Matlab and for personal interest Haskell. For the two topic of data structures and algorithms, I understand there are standard ones across all programming languages. After learning it through C, what would be the biggest issue when trying to implement the same data...
Back
Top