I got confused by that too. When they tell you to use the flag `-style=file` they literally mean for you to type out `-style=file`, NOT `-style=&lt;path/to/actual/filename&gt;`. 

With this flag, `clang-format` will look for a file called `.clang-format` in the directory of the target file. If it doesn&#39;t find any it will `cd ..` and try again. There doesn&#39;t seem to be a way to tell `clang-format` to use a file that is not named exactly `.clang-format`.

The correct usage for your example would be:

    ./clang-format -style=llvm -dump-config &gt; ~/.clang-format
    ./clang-format -style=file ~/myFile.cc

(updated 2022-02-25) [clang 14.0.0-RC1](https://github.com/llvm/llvm-project/releases/tag/llvmorg-14.0.0-rc1) or later now supports `-style=file:&lt;format_file_path&gt;` after this change [&quot;Add option to explicitly specify a config file&quot;](https://reviews.llvm.org/D72326) entered the [main branch](https://github.com/llvm/llvm-project/). It&#39;s [documented here](https://clang.llvm.org/docs/ClangFormat.html). This worked for me:

```
.\LLVM14.0.0RC1\bin\clang-format.exe test.cpp -style=file:my_clang_format.txt
```

Just an additional hint:
(in my case on Windows 10)
- if you dump the config to a file, check the ascii coding afterwards, e.g. in Notepad++
- the .clang-format file has to be utf8 without BOM !!! (you can convert it in Notepadd++) 
- otherwise you get an error like &quot;YAML:1:4: error: Got empty plain scalar&quot;
- place the .clang-format file in the same folder or in a parent directory of the code-file.c

A correct command line call to format the code-file.c would look like that:
clang-format.exe -style=file -i C:\path\code-file.c


For example:

    class Base {
      virtual void my_function() = 0;
    };

    class Derived : Base {
      void my_function() override;
    };

From what I read, the `override` keyword is used to make sure that we have the correct signature in the function that we are overriding, and it seems to be its only use.

However, in the case of a pure virtual function, the compiler would throw an error if we used an incorrect signature in the Derived class (or Base class, depending on how one see things). So, is there any point in adding `override` at the end of `Derived::my_function()` declaration?

Is there any point in using `override` when overriding a pure virtual function?

I do pull requests in a repo where it&#39;s always the same person reviewing.
I would like to set him as the default reviewer so that I don&#39;t always have to choose him at each pull request, it&#39;d be automatic.
How to do that ?

Set a default reviewer

I just built clang 5.0.0 on a Redhat 6 machine and tried to run clang-format. I&#39;m unable to get the -style option to read in a style file. Here&#39;s an example of a set of commands that I think should work:

    ./clang-format -style=llvm -dump-config &gt; .llvm-format
    ./clang-format -style=.llvm-format ~/myFile.cc

When I run this command I get the following error:

    Invalid value for -style

It appears to find and use .clang-format when placed in a parent directory as expect. The built-in types also work:

    ./clang-format -style=Mozilla ~/myFile.cc

The problem, then, is that I can&#39;t specify explicitly a .clang-format file to use. Is this a problem with my build or am I misusing clang-format oir misunderstanding the documentation?

How do I specify a clang-format file?

I just built clang 5.0.0 on a Redhat 6 machine and tried to run clang-format. I'm unable to get the -style option to read in a style file. Here's an example of a set of commands that I think should work:
<pre><code class="hljs language-lua">./clang-format -style=llvm -dump-config > .llvm-format
./clang-format -style=.llvm-format ~/myFile.cc
</code></pre>
When I run this command I get the following error:
<pre><code class="hljs">Invalid value for -style
</code></pre>
It appears to find and use .clang-format when placed in a parent directory as expect. The built-in types also work:
<pre><code class="hljs language-bash">./clang-format -style=Mozilla ~/myFile.cc
</code></pre>
The problem, then, is that I can't specify explicitly a .clang-format file to use. Is this a problem with my build or am I misusing clang-format oir misunderstanding the documentation?

I have a [Heaviside step function][1] centered on unity for any data type, which I&#39;ve encoded using:

    template &lt;typename T&gt;
    int h1(const T&amp; t){
       if (t &lt; 1){
           return 0;
       } else if (t &gt;= 1){
           return 1;
       }
    }

In code review, my reviewer told me that there is not an explicit return on all control paths. And the compiler does not warn me either. But I don&#39;t agree; the conditions are mutually exclusive. How do I deal with this?

  [1]: https://en.wikipedia.org/wiki/Heaviside_step_function


Does this function have explicit return values on all control paths?

Consider these two approaches that can represent an &quot;optional `int`&quot;:

    using std_optional_int = std::optional&lt;int&gt;;
    using my_optional_int = std::pair&lt;int, bool&gt;;

Given these two functions...

    auto get_std_optional_int() -&gt; std_optional_int 
    {
        return {42};
    }
    
    auto get_my_optional() -&gt; my_optional_int 
    {
        return {42, true};
    }

...both **g++ trunk** and **clang++ trunk** *(with `-std=c++17 -Ofast -fno-exceptions -fno-rtti`)* produce the following assembly:

    get_std_optional_int():
            mov     rax, rdi
            mov     DWORD PTR [rdi], 42
            mov     BYTE PTR [rdi+4], 1
            ret
    
    get_my_optional():
            movabs  rax, 4294967338 // == 0x 0000 0001 0000 002a
            ret

[**live example on godbolt.org**](https://godbolt.org/g/XWkbhn)

---

**Why does `get_std_optional_int()` require three `mov` instructions, while `get_my_optional()` only needs a single `movabs`?** Is this a QoI issue, or is there something in `std::optional`&#39;s specification preventing this optimization?



Also please note that users of the functions might be completely optimized out regardless:

    volatile int a = 0;
    volatile int b = 0;
    
    int main()
    {
        a = get_std_optional_int().value();
        b = get_my_optional().first;
    }

...results in:

    main:
            mov     DWORD PTR a[rip], 42
            xor     eax, eax
            mov     DWORD PTR b[rip], 42
            ret

Why is the construction of std::optional&lt;int&gt; more expensive than a std::pair&lt;int, bool&gt;?

Some time ago my old teacher posted this code saying that it is another way to initialize an array to the same number (other than zero of course).

Three in this case.

He said that this way is slightly better than the `for` loop. Why do I need the left shift operator? Why do I need another array of long?
I don&#39;t understand anything what&#39;s happening here.

    int main() {

        short int A[100];

        long int v = 3;
        v = (v &lt;&lt; 16) + 3;
        v = (v &lt;&lt; 16) + 3;
        v = (v &lt;&lt; 16) + 3;
        long *B = (long*)A;

        for(int i=0; i&lt;25; i++)
            B[i] = v;

        cout &lt;&lt; endl;
        print(A,100);
    }



Initialize all the elements of an array to the same number

Suppose I have three compiled objects, all produced by the *same compiler/version*:

1. A was compiled with the C++11 standard
2. B was compiled with the C++14 standard
3. C was compiled with the C++17 standard

For simplicity, let&#39;s assume all headers were written in C++11, _using only constructs whose semantics haven&#39;t changed between all three standard versions_, and so any interdependencies were correctly expressed with header inclusion and the compiler did not object.

Which combinations of these objects is it and isn&#39;t it safe to link into a single binary? Why?

---
EDIT: answers covering major compilers (e.g. gcc, clang, vs++) are welcome

Is it safe to link C++17, C++14, and C++11 objects

Sometimes compilers generate code with weird instruction duplications that can safely be removed. Consider the following piece of code:

    int gcd(unsigned x, unsigned y) {
      return x == 0 ? y : gcd(y % x, x);
    }

Here is the assembly code (generated [by clang 5.0][1] with optimizations enabled):

    gcd(unsigned int, unsigned int): # @gcd(unsigned int, unsigned int)
      mov eax, esi
      mov edx, edi
      test edx, edx
      je .LBB0_1
    .LBB0_2: # =&gt;This Inner Loop Header: Depth=1
      mov ecx, edx
      xor edx, edx
      div ecx
      test edx, edx
      mov eax, ecx
      jne .LBB0_2
      mov eax, ecx
      ret
    .LBB0_1:
      ret
In the following snippet:

      mov eax, ecx
      jne .LBB0_2
      mov eax, ecx
If the jump doesn&#39;t happen, `eax` is reassigned for no obvious reason.

The other example is two ret&#39;s at the end of the function: one would perfectly work as well.

Is the compiler simply not intelligent enough or there&#39;s a reason to not remove the duplications?


  [1]: https://godbolt.org/g/uLqQNv

Why do compilers duplicate some instructions?

With most C/C++ compilers, there&#39;s a flag passable to the compiler, `-march=native`, which tells the compiler to tune generated code for the micro-architecture and ISA extensions of the host CPU. Even if it doesn&#39;t go by the same name, there&#39;s typically an equivalent option for LLVM-based compilers, like `rustc` or `swiftc`.

In my own experience, this flag can provide massive speedups for numerically-intensive code, and it _sounds_ like it would be free of compromises for code you&#39;re just compiling for your own machine. That said, I don&#39;t think I&#39;ve seen any build system or static compiler that enables it by default:

- Obviously, any command-line compiler executable that requires you to pass it doesn&#39;t use it by default.

- I can&#39;t think of any IDE that enables this by default.

- I can&#39;t think of any common build system I&#39;ve worked with (`cmake`, `automake`, `cargo`, `spm`, etc.) that enables it by default, even for optimized builds.

I can think of a few reasons for this, but none of them are really satisfactory:

- Using `-march=native` is inappropriate for binaries that will be distributed to other machines. That said, I find myself compiling sources for my own machine much more often than for others, and this doesn&#39;t explain its lack of use in debug builds, where there&#39;s no intention for distribution.

- At least on Intel x86 CPUs, it&#39;s my understanding that using AVX instructions infrequently could degrade performance or power efficiency, since the AVX unit is powered down when not in use, requiring it to be powered up to be used, and a lot of Intel CPUs downclock to run AVX instructions. Still, it only explains why AVX wouldn&#39;t be enabled, not why the code wouldn&#39;t be tuned for the particular micro-architecture&#39;s handling of regular instructions.

- Since most x86 CPUs use fancy out-of-order superscalar pipelines with register renaming, tuning code for a particular micro-architecture probably isn&#39;t particularly important. Still, if it _could_ help, why not use it?

Why is -march=native used so rarely?

I&#39;ve had a super frustrating bug in my code for the past few weeks. My code would work exactly as expected on my computer, but as soon as I farmed it out to the HPC server, it would produce weird results.

I&#39;ve boiled it down to this: on my computer (iMac) the function `abs()` works with floating point numbers, but on the server `abs()` truncates it to an integer.

Example:

Server

    abs(-1.1341234) = 1

My Mac

    abs(-1.1341234) = 1.1341234

Now I know I can fix this by using `fabs()`, that&#39;s not the question. I looked at the versions of `gcc` on either machine and this is the output:

Server

    g++ -v
    Using built-in specs.
    COLLECT_GCC=g++
    COLLECT_LTO_WRAPPER=/apps/software/GCCcore/5.4.0/libexec/gcc/x86_64-unknown-linux-gnu/5.4.0/lto-wrapper
    Target: x86_64-unknown-linux-gnu
    Configured with: ../configure --enable-languages=c,c++,fortran --enable-lto --enable-checking=release --disable-multilib --enable-shared=yes --enable-static=yes --enable-threads=posix --enable-gold=default --enable-plugins --enable-ld --with-plugin-ld=ld.gold --prefix=/apps/software/GCCcore/5.4.0 --with-local-prefix=/apps/software/GCCcore/5.4.0 --enable-bootstrap --with-isl=/dev/shm/GCCcore/5.4.0/dummy-/gcc-5.4.0/stage2_stuff
    Thread model: posix
    gcc version 5.4.0 (GCC) 

My Mac

    g++ -v
    Configured with: --prefix=/Library/Developer/CommandLineTools/usr --with-gxx-include-dir=/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include/c++/4.2.1
    Apple LLVM version 10.0.1 (clang-1001.0.46.3)
    Target: x86_64-apple-darwin18.5.0
    Thread model: posix
    InstalledDir: /Library/Developer/CommandLineTools/usr/bin

So my question, why does `abs()` produce different results between gcc and clang? This issue literally cost me 3 weeks of progress, so as you can imagine I&#39;m a little salty just now...

Why is `abs()` implemented differently?

I am curious why the following piece of code:

    #include &lt;string&gt;
    int main()
    {
        std::string a = &quot;ABCDEFGHIJKLMNO&quot;;
    }

when compiled with `-O3` yields the following code:

    main:                                   # @main
        xor     eax, eax
        ret

(I perfectly understand that there is no need for the unused `a` so the compiler can entirely omit it from the generated code)

However the following program:

    #include &lt;string&gt;
    int main()
    {
        std::string a = &quot;ABCDEFGHIJKLMNOP&quot;; // &lt;-- !!! One Extra P 
    }

yields:

	main:                                   # @main
	        push    rbx
	        sub     rsp, 48
	        lea     rbx, [rsp + 32]
	        mov     qword ptr [rsp + 16], rbx
	        mov     qword ptr [rsp + 8], 16
	        lea     rdi, [rsp + 16]
	        lea     rsi, [rsp + 8]
	        xor     edx, edx
	        call    std::__cxx11::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;::_M_create(unsigned long&amp;, unsigned long)
	        mov     qword ptr [rsp + 16], rax
	        mov     rcx, qword ptr [rsp + 8]
	        mov     qword ptr [rsp + 32], rcx
	        movups  xmm0, xmmword ptr [rip + .L.str]
	        movups  xmmword ptr [rax], xmm0
	        mov     qword ptr [rsp + 24], rcx
	        mov     rax, qword ptr [rsp + 16]
	        mov     byte ptr [rax + rcx], 0
	        mov     rdi, qword ptr [rsp + 16]
	        cmp     rdi, rbx
	        je      .LBB0_3
	        call    operator delete(void*)
	.LBB0_3:
	        xor     eax, eax
	        add     rsp, 48
	        pop     rbx
	        ret
	        mov     rdi, rax
	        call    _Unwind_Resume
	.L.str:
	        .asciz  &quot;ABCDEFGHIJKLMNOP&quot;

when compiled with the same `-O3`. I don&#39;t understand why it does not recognize that the `a` is still unused, regardless that the string is one byte longer.

This question is relevant to gcc 9.1 and clang 8.0, (online: https://gcc.godbolt.org/z/p1Z8Ns) because other compilers in my observation either entirely drop the unused variable (ellcc) or generate code for it regardless the length of the string.


Compiler stops optimizing unused string away when adding characters

I tried to check out where `float` loses the ability to exactly represent large integer numbers. So I wrote this little snippet:

    int main() {
        for (int i=0; ; i++) {
            if ((float)i!=i) {
                return i;
            }
        }
    }

This code seems to work with all compilers, except clang. Clang generates a simple infinite loop. [Godbolt](https://godbolt.org/z/ck_uVe).

Is this allowed? If yes, is it a QoI issue?

Is this floating-point optimization allowed?

I&#39;m getting the error `LLVM Profile Error: Failed to write file &quot;default.profraw&quot;: Permission denied` after running unit tests in Xcode. I don&#39;t know where Xcode is trying to write this file to. 

What folder should I grant permissions for?

LLVM Profile Error: Failed to write file &quot;default.profraw&quot;: Permission denied

I know that an *&quot;undefined behaviour&quot;* in C++ can pretty much allow the compiler to do anything it wants. However, I had a crash that surprised me, as I assumed that the code was safe enough.

In this case, the real problem happened only on a specific platform using a specific compiler, and only if optimization was enabled.

I tried several things in order to reproduce the problem and simplify it to the maximum. Here&#39;s an extract of a function called `Serialize`, that would take a bool parameter, and copy the string `true` or `false` to an existing destination buffer.

Would this function be in a code review, there would be no way to tell that it, in fact, could crash if the bool parameter was an uninitialized value?

    // Zero-filled global buffer of 16 characters
    char destBuffer[16];
    
    void Serialize(bool boolValue) {
        // Determine which string to print based on boolValue
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        const size_t len = strlen(whichString);
        
        // Copy string into destination buffer, which is zero-filled (thus already null-terminated)
        memcpy(destBuffer, whichString, len);
    }

If this code is executed with clang 5.0.0 + optimizations, it will/can crash.

The expected ternary-operator `boolValue ? &quot;true&quot; : &quot;false&quot;` looked safe enough for me, I was assuming, &quot;Whatever garbage value is in `boolValue` doesn&#39;t matter, since it will evaluate to true or false anyhow.&quot;

I have setup a [Compiler Explorer example](https://godbolt.org/z/DoFmhA) that shows the problem in the disassembly, here the complete example. *Note: in order to repro the issue, the combination I&#39;ve found that worked is by using Clang 5.0.0 with -O2 optimisation.*

    #include &lt;iostream&gt;
    #include &lt;cstring&gt;
    
    // Simple struct, with an empty constructor that doesn&#39;t initialize anything
    struct FStruct {
        bool uninitializedBool;
        
       __attribute__ ((noinline))  // Note: the constructor must be declared noinline to trigger the problem
       FStruct() {};
    };
    
    char destBuffer[16];
    
    // Small utility function that allocates and returns a string &quot;true&quot; or &quot;false&quot; depending on the value of the parameter
    void Serialize(bool boolValue) {
        // Determine which string to print depending if &#39;boolValue&#39; is evaluated as true or false
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        size_t len = strlen(whichString);
        
        memcpy(destBuffer, whichString, len);
    }
    
    int main()
    {
        // Locally construct an instance of our struct here on the stack. The bool member uninitializedBool is uninitialized.
        FStruct structInstance;
        
        // Output &quot;true&quot; or &quot;false&quot; to stdout
        Serialize(structInstance.uninitializedBool);
        return 0;
    }

The problem arises because of the optimizer: It was clever enough to deduce that the strings &quot;true&quot; and &quot;false&quot; only differs in length by 1. So instead of really calculating the length, it uses the value of the bool itself, which *should* technically be either 0 or 1, and goes like this:

    const size_t len = strlen(whichString); // original code
    const size_t len = 5 - boolValue;       // clang clever optimization

While this is &quot;clever&quot;, so to speak, my question is: **Does the C++ standard allow a compiler to assume a bool can only have an internal numerical representation of &#39;0&#39; or &#39;1&#39; and use it in such a way?**

Or is this a case of implementation-defined, in which case the implementation assumed that all its bools will only ever contain 0 or 1, and any other value is undefined behaviour territory?

Content Type	Original Author	Original Content on Stackoverflow
Question	dromodel	View Question on Stackoverflow
Solution 1 - C++	nwp	View Answer on Stackoverflow
Solution 2 - C++	Dwayne Robinson	View Answer on Stackoverflow
Solution 3 - C++	tk6037	View Answer on Stackoverflow

How do I specify a clang-format file?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Set a default reviewer

Is there any point in using `override` when overriding a pure virtual function?

Attributions