S
Ich muss nach einigen Jahren Abstinenz wieder etwas C++ programmieren und will mir gerade die storage classes wieder einverleiben, bin aber teilweise noch etwas am Holzweg. Außerdem ist mir noch nicht ganz klar was das neue "inline" jeweils genau modifiziert. Vielleicht könnt ihr mir auf die Sprünge helfen und mein Zusammengeschriebens ergänzen bzw. dort wo mir Dinge unklar sind aushelfen:
// * Declared & defined here
// * Must be a compile-time constant
// * May be completely inlined by the compiler at compile-time
// * Has no address
constexpr int constexprInt = 5;
// * Declared here, defined somewhere else
// * Does not have to be a compile-time constant
// * Reasons: to be able to update the value by updating just the library, to use private methods to initialize it, etc.
// * Each compile unit references the same external instance (i.e., every cpp that includes this header sees the same address)
const extern int constExternInt;
// * Declare & defined here
// * Does not have to be a compile-time constant
// * Each compile unit gets its own instance (i.e., every cpp that includes this header sees a different address)
// * Reasons to use this approach over extern?
const static int constStaticInt = 5;
// * Equivalent to constStaticInt?
const int constInt = 5;
// * I'm completely unsure what inline gives me over constexprInt? Maybe constexpr is always inline?
constexpr inline int constexprInlineInt = 5;
// * I'm completely unsure what inline gives me over constExternInt? Maybe extern is always inline? Sounds wrong...
const extern inline int constExternInlineInt;
// * In contrast to constStaticInt, everybody sees the same address again? Soooo, it's kinda like extern, with the only difference that we can put the initialization in here?
const static inline int constStaticInlineInt = 5;
// * Equivalent to constStaticInlineInt
const inline int constInlineInt = 5;
// * Declared here, defined somewhere else
// * Use this by default if putting an object in a header?
extern int externInt;
// * Declared here, defined here
// * Each compile unit gets its own instance (which, in contrast to constStaticInt, makes sense to me, because the value can be different)
static int staticInt = 5;
// * Equivalent to staticInt?
//int Int;
// * I'm completely unsure what inline gives me over externInt? Maybe extern is always inline? Sounds wrong...
extern inline int externInlineInt;
// * In contrast to staticInt, everybody sees the same address again? Soooo, it's kinda like extern, with the only difference that we can put the initialization in here?
static inline int staticInlineInt = 5;
// * Equivalent to staticInlineInt?
inline int inlineInt = 5;
Freue mich über jeden guten Input
MfG SideWinder
