Does C have One Definition Rule like C++?

by

I think what you’re looking for is chapter §6.2.7 from the C11 standard, Compatible type and composite type, (emphasis mine)

All declarations that refer to the same object or function shall have compatible type;
otherwise, the behavior is undefined.

and related to compatible type,

Two types have compatible type if their types are the same.

In your case, int and unsigned int are not compatible types. Hence undefined behavior.

Just to add a bit of clarity, in your source 2, unsigned int var_global; is a declaration, and it does not match the other declatation (and definition), so, this is UB.

That said, a statement like

 printf("%d \n",var_global);

will always consider the argument to %d to be of type int. In case the type and the format specifier does not match, you’ll again invoke undefined behavior.

EDIT:

After the edit, the answer is, use -fno-common to get the desired error. (missing extern is what you’re bothered with, I believe).

Quoting from online GCC manual,

-fno-common

In C code, controls the placement of uninitialized global variables. Unix C compilers have traditionally permitted multiple definitions of such variables in different compilation units by placing the variables in a common block. This is the behavior specified by -fcommon, and is the default for GCC on most targets. On the other hand, this behavior is not required by ISO C, and on some targets may carry a speed or code size penalty on variable references. The -fno-common option specifies that the compiler should place uninitialized global variables in the data section of the object file, rather than generating them as common blocks. This has the effect that if the same variable is declared (without extern) in two different compilations, you get a multiple-definition error when you link them. In this case, you must compile with -fcommon instead. Compiling with -fno-common is useful on targets for which it provides better performance, or if you wish to verify that the program will work on other systems that always treat uninitialized variable declarations this way.

I don’t know of any mention of the wordings “one definition rule” in the C standard, but along the line, you can look into annex §J.5.11, Multiple external definitions,

There may be more than one external definition for the identifier of an object, with or
without the explicit use of the keyword extern; if the definitions disagree, or more than
one is initialized, the behavior is undefined.

More Related Contents:

  1. Why does `int ;` compile fine in C, but not in C++?
  2. What is the purpose of a declaration like int (x); or int (x) = 10;
  3. Order of evaluation of arguments using std::cout
  4. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  5. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  6. Is `long` guaranteed to be at least 32 bits?
  7. Is a pointer with the right address and type still always a valid pointer since C++17?
  8. How is P0522R0 breaking code?
  9. Do I really need to implement user-provided constructor for const objects?
  10. Do all pointers have the same size in C++?
  11. Force all classes to implement / override a ‘pure virtual’ method in multi-level inheritance hierarchy
  12. Can class template constructors have a redundant template parameter list in c++20
  13. Is std::abs(0u) ill-formed?
  14. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  15. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  16. C++11 – declaring non-static data members as ‘auto’
  17. Does accessing the first field of a struct via a C cast violate strict aliasing?
  18. Implementing a std::vector like container without undefined behavior
  19. C++ – Why static member function can’t be created with ‘const’ qualifier
  20. Will consteval functions allow template parameters dependent on function arguments?
  21. Is a constexpr array necessarily odr-used when subscripted?
  22. Classes with both template and non-template conversion operators in the condition of switch statement
  23. Is it allowed for a compiler to optimize away a local volatile variable?
  24. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  25. Are global variables in C++ stored on the stack, heap or neither of them?
  26. Why is `make_unique` disallowed?
  27. What is default storage class for global variables?
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. Why don’t I need to specify “typename” before a dependent type in C++20?
  30. memcpy/memmove to a union member, does this set the ‘active’ member?

Leave a Comment