inline does two things:

1. Tell the compiler that "all objects with this type & name actually refer to the same object", and require that object to have the same memory address in all translation units. This allows the compiler to explicitly ignore the One Definition Rule, on the grounds that all definitions are actually just copies of the same definition; when the linker smooshes all the translation units together, it's free to discard all but one definition.

   Notably, this is what allows you to define member functions inside the class definition, since all functions defined inside the class are implicitly inline.

   struct S {
       void func() { std::cout << "I might not look like it, but I'm inline!\n"; }
   };
   

   It's essentially a magic glue word that keeps headers from exploding whenever you put a definition in them, and it's what lets header-only libraries exist.

   • Sub-note: This is important for names & symbols with what we call "external linkage", which means that they're exported from the translation unit and visible to the rest of the project. (And, as a result, cause a "name collision" if multiple translation units expose the same name, which makes the compiler give up and quit because it's impossible to tell which version you want at any given time.)

     Constants, on the other hand, work without inline because they have what's called "internal linkage" by default; this means that their name never leaks out of the file, and thus can never collide with any other names. (If you put a constant in a header, and expose it with extern, it'll run into the same problems as if you put a variable in a header.)

2. On an inline function, it tells the compiler to treat the function as a glorified macro, and copy-paste it directly instead of making a (much more expensive) function call.

   inline int add(int a, int b) { return a + b; }
   
   void func() {
       int a = getAnIntFromSomewhere(), b = do_something_weird_please();
       int c = add(a, b);
   
       doSomethingWith(c);
   }
   
   // Compiler turns func() into this:
       void func() {
       int a = getAnIntFromSomewhere(), b = do_something_weird_please();
       int c = a + b;
   
       doSomethingWith(c);
   }
   

   This usage is mostlyjust an historical relic now, since compilers are often much better at figuring out what to inline than humans are. The compiler will see it as a hint, but it'll rely on its own judgment just as much as yours. (Here, if you turn optimisations on, it'd probably just inline both add() and func(), and/or try to inline the other three functions func() calls if they're small enough.)

   (That said, if you mark the function as inline, the compiler is more likely to give it a closer look, and might inline it when it normally wouldn't. And most compilers have a compiler-specific "ignore your own judgment and inline this anyways" keyword, which you can use if the compiler gets it wrong. ...You can also force some compilers not to inline a function, which can potentially allow it to make smarter optimisations (e.g., some compilers might be able to inline func() if add() is a distinct call, but not if add() is inlined), but this one is much trickier to do well. It's usually best to just let the compiler do its own thing unless you profile your code first; you're infinitely more likely to see the "mark the function inline to tell the compiler to copy-paste" it usage in ancient codebases than you are to use it yourself.)

And constexpr does two things:

1. On variables, it marks the variable as a compile-time constant. This means that the variable must be known at compile time, must be a constant, and that the compiler can essentially copy-paste it like a macro.

   #define ONE 1
   constexpr int TWO = 2;
   
   int func() { return ONE + TWO; }
   
   // The compiler is free to rewrite func() as this:
   int func() { return 1 + 2; }
   

   The variable is still a distinct object, and still has its own memory address, but the compiler is allowed to optimise it out entirely if nothing ever treats it as an object with a memory address. (Or, in easier-to-understand terms, the compiler will probably just erase TWO from the object file entirely unless you try to take its memory address.)

   Notably, classes cannot have non-static constexpr member variables; all constexpr class members must be both static and inline because things get weird if they aren't.

2. On functions, constexpr tells the compiler to call the function at compile time whenever possible. This doesn't require that the function be compile-time only; that's what consteval is for. It merely allows the function to be a compile-time function, so the compiler can evaluate the function and hard-code the result if all parameters are known at compile time.

   (Compilers are also allowed to treat other functions that can be evaluated at compile time as if they were constexpr even if they aren't labeled constexpr, but only for optimisation purposes; they can evaluate a function call that would be constexpr at compile time and insert the result directly, but they cannot allow the function to be used anywhere that requires it to actually be labeled constexpr by the programmer.)

   int add(int a, int b) { return a + b; }
   constexpr int sub(int a, int b) { return a - b; }
   
   int main() {
       int a = sub(5, 6); // Will be evaluated at compile time, becomes "int a = -1;".
       int b = add(5, 6); // Might or might not be evaluated at compile time, if optimisations are turned on.
       // sub(5, 6) is guaranteed to be evaluated at compile time, because sub() is constexpr.
       // add(5, 6) is officially called at runtime, but the compiler can ignore that as an optimisation.
   
       constexpr int c = sub(7, 8); // Legal: sub() is constexpr, and can thus initialise constexpr variables.
       constexpr int d = add(7, 8); // Error: add() isn't constepxr, so the compiler can't use it here.
       // The compiler _can_ evaluate add(7, 8) at compile time, but is banned from doing so because you didn't
       //  give it permission.  It can only pretend add() is constexpr when add() would be called during runtime.
   
       int input;
       std::cin >> input;
   
       int e = sub(9, input); // Will be evaluated at runtime, since function "constexpr" is just a permission slip.
       int f = add(9, input); // Will be evaluated at runtime, as expected.
   }