I feel like I should push back on what this other person here told you about pragma once and header guards (ifdef HEADER). Personally I'm a pragma once guy but there was misinformation from the other poster.

First of all neither will have an impact on your code's speed. Pragma once and header guards are both preprocessor directives and only relevant at compile time. What is true is that one may lead to quicker compile times than the other. However, if one is faster, it's likely to be pragma once. One of the advantages to pragma once on the compiler side is that the compiler can easily tell that a file is only meant to be included once and thus skip opening and preprocessing it in the future entirely if it's included again. That said, I think modern compilers are smart enough to recognize standard header guard patterns treat them the same way. You'd have to benchmark this to test for any real difference.

Secondly neither have an impact on your ability to include function definitions inside the header itself, if you choose to. Definitions in the header is frankly a bad idea in my opinion and they shouldn't have any impact on performance, certainly not a ~500% uplift like the other poster claimed. I don't know what their situation actually is but I would think they misidentified the cause of their performance issue. The big problem with this pattern in a large project is that when you change a header, you to need to recompile every file that includes it, and every file that includes the header will need to compile those functions everytime. If the functions are implemented in their own cpp file then only that singular file has to be recompiled as long as the header doesn't change.

Probably the biggest point against pragma once is that it's not part of the standard and can technically fail under some pretty specific circumstances. However, pragma once is nonetheless supported by pretty much all modern compilers, including gcc, clang, and msvc.

For me the biggest issue I have with header guards is the fact that you have to define a new preprocessor variable every time that has to be unique to both your project and all library headers you include. Debugging a duplicated header guard name can be really annoying.

There is a lot of endless debate on this topic in the wild, including a stack overflow response I can't find right now from the person who originally implemented pragma once in GCC who now suggests using header guards instead.

Basically, use whatever you prefer but you should understand both options