What does Segment Violation mean?

Segmentation fault - segment violation.

What does it mean?

This is a very common type of runtime error for C/C++.

When the program runs and your system's reporting system throws a "segmentation violation", it means that your program has tried to access an area of ​​memory that it is not allowed to access. In other words, you tried to access a part of the memory that is beyond the limits that the operating system (Unix GNU/Linux ect) has allocated for your program.

Why it happens

Some common causes of this problem:

• The incorrect use of the operators "&"(direction/address of) and "*" (indirection/dereferencing)
• Malformed control string in printf or scanf statements

Format control strings must have the same number of conversion specifiers (%'s)and arguments to be printed or read, and the specifiers must match the type of the variable to be printed or read. This applies to fprintf and fscanf as well as printf and scanf.

• Forget to use "&"in scanf arguments (this case is the one mentioned by Elenasys)

The scanf function takes as arguments the format control string and the addresses of the variables into which the data to be read is to be placed (the operator "&"is used to supply the address of a variable). It's common to forget to use "&"each variable in a scanf call. Omitting the "&"can cause a segmentation violation.

• Access to beyond the limits of an array/vector or similar: try to access subscripts of the array with a value less than the index of its lowest element or greater than the index of its highest element.

• Error initializing a pointer before accessing it: A "pointer" variable must be assigned a valid memory address.

  int *ip;
  std::cout << *ip << std::endl; //usar un puntero no inicializado
  

• Trying to access a part of memory improperly even though it is accessible to your program.

  char *str = "string";// static array de caracteres, sin nombre/id 
                       // este array se crea en modo "read-only memory"
                       // como solo lectura
  str[0]    = 'n';
  

• Attempting to access an object or variable that has been cleared from memory, e.g.:

  int *pArrI = new int[9];//solicitamos en el heap 
  delete[] pArrI;         //eliminamos
  std::cout << pArrI[1];  //intentamos acceder a una parte inexistente
  

On a Unix system with virtual memory, each process has memory regions that it can access. For example, on Linux, you can see the Virtual Memory Areas (VMAs) of a process by reading the virtual file /proc/<pid>/maps:

$ cat /proc/self/maps 
08048000-0804c000 r-xp 00000000 03:04 1553592    /bin/cat
0804c000-0804d000 rw-p 00003000 03:04 1553592    /bin/cat
08d7c000-08d9d000 rw-p 08d7c000 00:00 0          [heap]
b7da2000-b7da3000 rw-p b7da2000 00:00 0 
b7da3000-b7eeb000 r-xp 00000000 03:04 2190352    /lib/libc-2.6.1.so
b7eeb000-b7eed000 r--p 00148000 03:04 2190352    /lib/libc-2.6.1.so
b7eed000-b7eee000 rw-p 0014a000 03:04 2190352    /lib/libc-2.6.1.so
b7eee000-b7ef2000 rw-p b7eee000 00:00 0 
b7f14000-b7f15000 r-xp b7f14000 00:00 0          [vdso]
b7f15000-b7f31000 r-xp 00000000 03:04 2190353    /lib/ld-2.6.1.so
b7f31000-b7f32000 r--p 0001b000 03:04 2190353    /lib/ld-2.6.1.so
b7f32000-b7f33000 rw-p 0001c000 03:04 2190353    /lib/ld-2.6.1.so
bfa1d000-bfa32000 rw-p bffeb000 00:00 0          [stack]

As you can see, you get a list of memory regions, with associated permissions ( r-read, w-write, x-execute).

If a process tries to access a memory zone that is not in the previous list, or an access is attempted for which it does not have permission, the processor's MMU (Memory Management Unit) will generate an exception, the kernel will treat that exception, referring to the list above, and finally, the kernel will send a signal SIGSEGVto the process.

The default action for SIGSEGVis to kill the process by generating a core dump .

There is another related signal, SIGBUS, which corresponds to a bus error. On some processors it will be obtained SIGBUSif an unaligned address is attempted to be accessed (for example, if a 4-byte word at an address not divisible by 4 bytes is attempted to be accessed). Another possible cause SIGBUSwould be if one of the regions corresponds to a memory-mapped physical device, and access to that physical address fails.

It is a concept that generally happens when:

A certain program tries to access a memory area to which it does not have access privileges.

Looking for a definition on the internet you have: Access Violation .

It is defined as a violation of access (violation of the segment or access violation and segmentation fault in English) to the failed attempt to access information or programs that you do not have authorization to see or modify. This message can be caused by software configuration, programmers, or hardware failure, the first 2 being the most common.

With today's operating systems, each process has one or more segments of system memory where it can store and retrieve information. Each process can request more or less memory (as needed), and the request will be recognized by the operating system and compared to the section of memory granted to the process. Generally, the process that requested the memory is the only one that can read or modify it.

An access violation occurs when a process tries to access a part of memory allocated to another application, or an unused area of ​​memory, without having the permissions to do so. It usually occurs as a result of a programming error, for example a stray pointer. Another way a segmentation fault could occur is with physically damaged memory, as some program will write to the memory, then try to access that data, but when the memory fails, the data may have been erased , therefore the program will consider that memory address as empty, that is, not used, which will throw the error.

A common example of how it can be produced, assuming in the following program we omit &:

#include <stdio.h>
int main ()
{
  int i;
  printf ("introduce tu edad: ");
  scanf ("%d",i);   //genera violación de segmento!
  printf ("Miss Elena, tu edad es: , %d.\n",i);
  return 0;
}

On the line:

  scanf ("%d",&i);  

Then an access violation occurs.

A segfault occurs when a process tries to access memory that does not belong to it or perform an operation for which it does not have permissions. Common examples are:

1. Attempt to access a variable that has already been freed.
2. Attempt to write to a read-only variable.