How to know the version of the C standard that I am using in code?

The best way to know which version of the standard you are compiling against is to use the preprocessor macro: __STDC_VERSION__, which is available as of C99 and its value is loaded with the following versions:

• __STDC_VERSION__ == 199409Lthe standard is C94¹ .
• __STDC_VERSION__ == 199901Lthe standard is C99.
• __STDC_VERSION__ == 201112Lis standard is C11.

For other standards, preprocessor macros are defined:

• __ANSI__for ANSI C (C89 and C90)
• __STDC__similarly for ANSI C ² .

It is worth mentioning that __STDC_VERSION__it is not defined when using standards GNU C, the same happens when using a C++ compiler.

A list of standards as of 2014 can be found:

Versión     Macro               Estándar
---------------------------------------------------
C89         __STDC__            ANSI X3.159-1989
C90         __STDC__            ISO/IEC 9899:1990
C94         __STDC_VERSION__    ISO/IEC 9899-1:1994
C99         __STDC_VERSION__    ISO/IEC 9899:1999
C11         __STDC_VERSION__    ISO/IEC 9899:2011
C++98       __cplusplus         ISO/IEC 14882:1998
C++11       __cplusplus         ISO/IEC 14882:2011
C++14       __cplusplus         ISO/IEC 14882:2014
C++/CLI     __cplusplus_cli     ECMA-372
...

Try the following program as an example:

#include <stdio.h>


int main(void) {
    #ifdef __STDC_VERSION__
        printf("Aparentemente compatible con __STDC_VERSION__\n");
    #   if __STDC_VERSION__ == 199901L
        printf("Este código fue compilando con el estandar C99.\n");
    #   elif __STDC_VERSION__ == 201112L
        printf("Este codigo fue compilado con el estandar C11.\n");
    #   else
        printf("Este codigo fue compilado con el estandar C94.\n");
    #   endif /* == */
    #endif /* __STDC_VERSION__ */


    #ifdef __cplusplus
        printf("Aparentemente compilado con un compilador de C++\n");
    #   if __cplusplus >= 201103L
        printf("Este codigo fue compilado bajo un estandar mayor o igual a C++11.\n");
    #   else
        printf("Este codigo fue compilado bajo un estandar menor a C++11.");
    #   endif /* >= */
    #endif /* __cplusplus */

    #ifdef __STDC__
        printf("Aparentemente compatible con __STDC__ y los estandares C89 y C90 ...\n");
    #endif /* __STDC__ */
}

When running it under the C99 standard:

gcc -o test -std=c99 test.c

I get the following result:

Aparentemente compatible con __STDC_VERSION__
Este código fue compilando con el estandar C99.
Aparentemente compatible con __STDC__ y los estandares C89 y C90 

And if I compile it with a C++ compiler under the C11 standard:

g++ -o test -std=c++11 test.c

The following result can be obtained:

Aparentemente compilado con un compilador de C++
Este codigo fue compilado bajo un estandar mayor o igual a C++11.
Aparentemente compatible con __STDC__ y los estandares C89 y C90 ...

Using that code you can tell which standard you are currently compiling, even with which compiler (Not its name, but the language) .

¹ : This standard is not supported by gcc.
² : This macro is defined in all standards with the value of 1, but its behavior can vary by compiler, so it is not totally reliable, unless you want to know if you are compiling with a C compiler, in a C compiler. C++ would not throw your definition.

References:

1. The C Preprocessor (gcc.gnu.org)
2. Pre-defined Compiler Macros

As additional information I would like to add the C++ feature presence macros.

A brief section of history.

The 2011 C++ standard (initially known as C++0x and later known as C++11) was the slowest standard to be approved (the previous standard was from 1998 ¹ ).

C++11 added many new features to the C++ language, so many that it made C++ seem like a new language. Given the large number of features to be implemented by compiler developers, adherence to the C++11 standard was spotty and incomplete among compilers for a long time.

This made it necessary to be able to check individual language features rather than standards (since the compiler could claim to be C++11 but lack some C++11 features); To make this possible, feature presence macros were created.

Feature presence macros.

Feature presence macros allow you to check whether a particular C++ feature is implemented in the current C++ compiler.

Features are divided into library features and language features, so macros follow the format:

• Language features: __cpp_nombre_de_la_característica.
• Library Features: __cpp_lib_nombre_de_la_característica.

List of feature macros.

• __cpp_noexcept_function_type: Make the exception specifications part of the function's signature. P0012R1 .
• __cpp_fold_expressions: Groupable expressions. N4191 , N4295 .
• __cpp_static_assert: Extension of static_assert. N3928 .
• __cpp_namespace_attributes: Attributes for namespaces. N4196 , N4266 .
• __cpp_enumerator_attributes: Attributes for enumerated.
• __cpp_nested_namespace_definitions: Nested namespace definitions. N4230 .
• __cpp_inheriting_constructors: Extension of legacy constructors. P0136R0 , P0136R1 .
• __cpp_nontype_template_args: Allow constant evaluation of non-type template parameters. N4198 , N4268 .
• __cpp_lib_uncaught_exceptions: Utility std::uncaught_exceptions. N4152 , N4259 .
• __cpp_lib_as_const: Utility std::as_const. P0007R1 .
• __cpp_lib_transparent_operators: Transparent operators (make it more flexible std::owner_less). P0074R0 .
• __cpp_lib_invoke: Utility std::invoke. N4169 .
• __cpp_lib_void_t: Utility std::void_t. N3911 .
• __cpp_lib_bool_constant: Utility std::bool_constant. [N4389]8 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4389.html).
• __cpp_lib_type_trait_variable_templates: Utility std::is_void_v. P0006R0 .
• __cpp_lib_logical_traits: Logical features. P0013R1 .
• __cpp_lib_chrono: Rounding functions for std::chrono::durationand std::chrono::time_point. P0092R1 .
• __cpp_lib_allocator_traits_is_always_equal: Cleanup of the standard library, removal of noexcept. N4258 .
• __cpp_lib_incomplete_container_elements: Incomplete types for standard containers. N4510 .
• __cpp_lib_map_try_emplace, __cpp_lib_map_try_emplace, __cpp_lib_unordered_map_try_emplace: Improvements to the insert interface in std::map::try_emplace, std::map::insert_or_assignand their equivalents in std::unordered_map. N4279 .
• __cpp_lib_nonmember_container_access: Uniform access to container utilities through free functions. N4280 .
• __cpp_lib_shared_mutex: Shared mutex without time limit. N4508 .
• __cpp_lib_lock_guard_variadic: std::lock_guardVariadic utility. P0156R0 .

• __cpp_binary_literals: Binary literals. N3472 .
• __cpp_init_captures: Generalized captures in lambdas. N3610 , N3648 .
• __cpp_generic_lambdas: generic lambdas. N3649 .
• __cpp_sized_deallocation: Operator deletewith size. N3778 .
• __cpp_constexpr: Relax the limitations of constexpr. N3652 .
• __cpp_decltype_auto, __cpp_return_type_deduction: Deduction of the return type in functions. N3638 .
• __cpp_aggregate_nsdmi: Member initializers in aggregates. N3653 .
• __cpp_variable_templates: Template variables. N3651 .
• __cpp_lib_integer_sequence: Utility std::integer_sequence. N3658 .
• __cpp_lib_exchange_function: Utility std::exchange(). N3668 .
• __cpp_lib_tuples_by_type: Access tuple members by type. N3670 .
• __cpp_lib_tuple_element_t: Utility std::tuple_element_t. N3887 .
• __cpp_lib_make_unique: Utility std::make_unique. N3656 .
• __cpp_lib_transparent_operators: Transparent operators (make it more flexible std::greater). N3421 .
• __cpp_lib_integral_constant_callable: Call operator in std::integral_constant. N3545 .
• __cpp_lib_transformation_trait_aliases: Utilities on transformation traits. N3655 .
• __cpp_lib_result_of_sfinae: Grants for the SFINAE technique . N3462 .
• __cpp_lib_is_final: Utility std::is_final. LWG 2112 .
• __cpp_lib_is_null_pointer: Utility std::is_null_pointer. LWG 2247 .
• __cpp_lib_chrono_udls, __cpp_lib_string_udls: User-defined literals for header types <chrono>and <string>. N3642 .
• __cpp_lib_generic_associative_lookup: Heterogeneous comparisons in associative containers. N3657 .
• __cpp_lib_null_iterators: null iterators. N3644 .
• __cpp_lib_make_reverse_iterator: Utility std::make_reverse_iterator. LWG 2285 .
• __cpp_lib_robust_nonmodifying_seq_ops: Provide greater robustness to operations on a sequence that do not modify it ( std::mismatch, std::equaland std::is_permutation}). N3671 .
• __cpp_lib_complex_udls: User-defined literals for the type std::complex. N3779 .
• __cpp_lib_quoted_string_io: Utility std::quoted. N3654 .
• __cpp_lib_shared_timed_mutex: Utility std::shared_timed_mutex. N3891 .

• __cpp_unicode_characters, __cpp_raw_strings, __cpp_unicode_literals: Unicode and raw text. N2249 . N2442 .
• __cpp_user_defined_literals: User-defined literals. N2765 .
• __cpp_lambdas: Lambdas. N2927 .
• __cpp_constexpr: Constant expressions. N2235 .
• __cpp_range_based_forfor: Range loop . N2930 .
• __cpp_static_assert: Static assertions. N1720 .
• __cpp_decltype: Type query operator decltype. N2343 .
• __cpp_attributes: C++ attributes. N2761 .
• __cpp_rvalue_references: References to values ​​on the right side. N2118 .
• __cpp_variadic_templates: Variadic templates. N2242 .
• __cpp_initializer_lists: Initialization lists. N2672 .
• __cpp_explicit_conversion: Explicit conversion operators. N2437 .
• __cpp_delegating_constructors: Delegated constructors. N1986 .
• __cpp_nsdmi: Initialization of non-static member data. N2756 .
• __cpp_inheriting_constructors: Legacy constructors. N2540 .
• __cpp_ref_qualifiers: Reference qualifiers. N2439 .
• __cpp_alias_templates: Template aliases. N2258 .

¹ There is an unofficial standard in 2003 known as C++03 which was not actually a standard per se but a collection of technical specifications.