View source for c/language/behavior

You do not have permission to edit this page, for the following reasons:

The action you have requested is limited to users in one of the groups: Users, Administrators.

Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).

You can view and copy the source of this page.

{{title|Undefined behavior}}
{{c/language/basics/navbar}}

The C language standard precisely specifies the {{rlp|as if|observable behavior}} of C language programs, except for the ones in the following categories:

* ''undefined behavior'' - there are no restrictions on the behavior of the program. Examples of undefined behavior are memory accesses outside of array bounds, signed integer overflow, null pointer dereference, modification of the same scalar {{rlp|eval order|more than once}} in an expression without sequence points, access to an object through a pointer of a different type, etc. Compilers are not required to diagnose undefined behavior (although many simple situations are diagnosed), and the compiled program is not required to do anything meaningful.

* ''unspecified behavior'' - two or more behaviors are permitted and the implementation is not required to document the effects of each behavior. For example, {{rlp|eval order|order of evaluation}}, whether identical {{rlp|string literal}}s are distinct, etc. Each unspecified behavior results in one of a set of valid results and may produce a different result when repeated in the same program.

* ''implementation-defined behavior'' - unspecified behavior where each implementation documents how the choice is made. For example, number of bits in a byte, or whether signed integer right shift is arithmetic or logical.

* ''locale-specific behavior'' - implementation-defined behavior that depends on the [[c/locale/setlocale|currently chosen locale]]. For example, whether {{lc|islower}} returns true for any character other than the 26 lowercase Latin letters.

(Note: {{rlp|conformance|Strictly conforming}} programs do not depend on any unspecified, undefined, or implementation-defined behavior)

The compilers are required to issue diagnostic messages (either errors or warnings) for any programs that violates any C syntax rule or semantic constraint, even if its behavior is specified as undefined or implementation-defined or if the compiler provides a language extension that allows it to accept such program. Diagnostics for undefined behavior are not otherwise required.

===UB and optimization===
Because correct C programs are free of undefined behavior, compilers may produce unexpected results when a program that actually has UB is compiled with optimization enabled:

For example,
====Signed overflow====
{{source|1=
int foo(int x)
{
    return x + 1 > x; // either true or UB due to signed overflow
}
}}
may be compiled as ([https://godbolt.org/z/9dh7b71TK demo])
{{source|
foo:
        mov     eax, 1
        ret
}}

====Access out of bounds====
{{source|1=
int table[4] = {0};
int exists_in_table(int v)
{
    // return 1 in one of the first 4 iterations or UB due to out-of-bounds access
    for (int i = 0; i <= 4; i++)
        if (table[i] == v)
            return 1;
    return 0;
}
}}
May be compiled as ([https://godbolt.org/z/48bn19Tsb demo])
{{source|
exists_in_table:
        mov     eax, 1
        ret
}}

====Uninitialized scalar====
{{source|
_Bool p; // uninitialized local variable
if (p) // UB access to uninitialized scalar
    puts("p is true");
if (!p) // UB access to uninitialized scalar
    puts("p is false");
}}
May produce the following output (observed with an older version of gcc):
{{source|
p is true
p is false
}}

{{source|1=
size_t f(int x)
{
    size_t a;
    if (x) // either x nonzero or UB
        a = 42;
    return a;
}
}}
May be compiled as ([https://godbolt.org/z/9nz6EMPTG demo])
{{source|
f:
        mov     eax, 42
        ret
}}

====Invalid scalar====
{{source|1=
int f(void)
{
    _Bool b = 0;
    unsigned char* p = (unsigned char*)&b;
    *p = 10;
    // reading from b is now UB
    return b == 0;
}
}}
May be compiled as ([https://godbolt.org/z/rjx77bjoh demo])
{{source|
f:
        mov     eax, 11
        ret
}}

====Null pointer dereference====
{{source|1=
int foo(int* p)
{
    int x = *p;
    if (!p)
        return x; // Either UB above or this branch is never taken
    else
        return 0;
}

int bar()
{
    int* p = NULL;
    return *p;    // Unconditional UB
}
}}
may be compiled as ([https://godbolt.org/z/8jnjMjcPz demo])
{{source|
foo:
        xor     eax, eax
        ret
bar:
        ret
}}

====Access to pointer passed to {{lc|realloc}}====
{{example|Choose clang to observe the output shown
|code=
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *p = (int*)malloc(sizeof(int));
    int *q = (int*)realloc(p, sizeof(int));
    *p = 1; // UB access to a pointer that was passed to realloc
    *q = 2;
    if (p == q) // UB access to a pointer that was passed to realloc
        printf("%d%d\n", *p, *q);
}
|p=true
|output=
12
}}
====Infinite loop without side-effects====
{{example|Choose clang to observe the output shown
|code=
#include <stdio.h>

int fermat()
{
    const int MAX = 1000;
    // Endless loop with no side effects is UB
    for (int a = 1, b = 1, c = 1; 1;)
    {
        if (((a * a * a) == ((b * b * b) + (c * c * c))))
            return 1;
        ++a;
        if (a > MAX)
        {
            a = 1;
            ++b;
        }
        if (b > MAX)
        {
            b = 1;
            ++c;
        }
        if (c > MAX)
            c = 1;
    }
    return 0;
}

int main(void)
{
    if (fermat())
        puts("Fermat's Last Theorem has been disproved.");
    else
        puts("Fermat's Last Theorem has not been disproved.");
}
|p=true
|output=
Fermat's Last Theorem has been disproved.
}}

===References===
{{ref std c23}}
{{ref std|section=3.4|title=Behavior|p=TBD}}
{{ref std|section=4|title=Conformance|p=TBD}}
{{ref std end}}
{{ref std c17}}
{{ref std|section=3.4|title=Behavior|p=3-4}}
{{ref std|section=4|title=Conformance|p=8}}
{{ref std end}}
{{ref std c11}}
{{ref std|section=3.4|title=Behavior|p=3-4}}
{{ref std|section=4/2|title=Undefined behavior|p=8}}
{{ref std end}}
{{ref std c99}}
{{ref std|section=3.4|title=Behavior|p=3-4}}
{{ref std|section=4/2|title=Undefined behavior|p=7}}
{{ref std end}}
{{ref std c89}}
{{ref std|section=1.6|title=DEFINITIONS OF TERMS}}
{{ref std end}}

===See also===
{{dsc begin}}
{{dsc see cpp|cpp/language/ub|Undefined behavior|nomono=true}}
{{dsc end}}

===External links===
{{elink begin}}
{{elink|1=[https://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html What Every C Programmer Should Know About Undefined Behavior #1/3]}}
{{elink|1=[https://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html What Every C Programmer Should Know About Undefined Behavior #2/3]}}
{{elink|1=[https://blog.llvm.org/2011/05/what-every-c-programmer-should-know_21.html What Every C Programmer Should Know About Undefined Behavior #3/3]}}
{{elink|1=[https://devblogs.microsoft.com/oldnewthing/20140627-00/?p=633 Undefined behavior can result in time travel (among other things, but time travel is the funkiest)]}}
{{elink|1=[https://www.cs.utah.edu/~regehr/papers/overflow12.pdf Understanding Integer Overflow in C/C++]}}
{{elink|1=[https://web.archive.org/web/20201108094235/https://kukuruku.co/post/undefined-behavior-and-fermats-last-theorem/ Undefined Behavior and Fermat’s Last Theorem]}}
{{elink|1=[https://lwn.net/Articles/342330/ Fun with NULL pointers, part 1] (local exploit in Linux 2.6.30 caused by UB due to null pointer dereference)}}
{{elink end}}

{{langlinks|ar|cs|de|es|fr|it|ja|ko|pl|pt|ru|tr|zh}}

Templates used on this page:

Template:! (view source) (protected)
Template:!! (view source)
Template:c/language/basics/navbar (view source)
Template:c/language/basics/navbar content (view source)
Template:c/language/basics/navbar heading (view source)
Template:c/language/navbar content (view source)
Template:c/language/navbar heading (view source)
Template:c/navbar content (view source)
Template:c/navbar heading (view source)
Template:dsc (view source) (protected)
Template:dsc begin (view source) (protected)
Template:dsc editlink (view source)
Template:dsc end (view source) (protected)
Template:dsc guard (view source) (protected)
Template:dsc see cpp (view source)
Template:elink (view source)
Template:elink begin (view source)
Template:elink end (view source)
Template:example (view source) (protected)
Template:get lang (view source) (protected)
Template:inc (view source)
Template:langlinks (view source) (protected)
Template:langlinks/one (view source) (protected)
Template:lc (view source) (protected)
Template:mark c11 (view source) (protected)
Template:mark rev (view source) (protected)
Template:navbar (view source)
Template:navbar editlink (view source) (protected)
Template:nv (view source) (protected)
Template:nv begin (view source) (protected)
Template:nv end (view source) (protected)
Template:nv h2 (view source) (protected)
Template:ref std (view source)
Template:ref std c11 (view source)
Template:ref std c17 (view source)
Template:ref std c23 (view source)
Template:ref std c89 (view source)
Template:ref std c99 (view source)
Template:ref std end (view source)
Template:rlp (view source) (protected)
Template:source (view source) (protected)
Template:title (view source) (protected)
Template:trim (view source) (protected)

Return to c/language/behavior.

cppreference.com

Search

Namespaces

Variants

Views

Actions

View source for c/language/behavior

Navigation

Tools