cppblog | Contains working code samples from my C blog | Application Framework library

I'm using Visual Studio to connect to a docker container via SSH for remote development using CMake as the build system. When Visual Studio launches the project for the first time or a CMakeLists.txt file has been altered, Visual Studio configures, allowing me to view, compile and run the CMake targets, and other CMake settings also become available in the UI (such as settings from the 'Project' drop down), however, when reopening the project, Visual Studio does not seem to detect the CMake Project or reconfigure automatically, meaning no targets are shown hence not possible to compile, or if shown don't work, and no settings for CMake are shown in the UI; I could theoretically update a CMakeLists.txt file which after relaunching again could cause a regenerate, causing Visual Studio to detect the project, show the targets and general settings relating to CMake in the UI, but this is not ideal and could cause the entire project to require recompiling.

Steps to reproduce:

1. Create C++ CMake Project in Visual Studio 2022
2. Run Docker container and add SSH connection info in Visual Studio options
3. Replace the default 'x64-Debug' in CMakeSettings.json with 'Linux-GCC-Debug'
4. Wait for automatic CMake generation or press Generate on the popup "C++ IntelliSense information may be out of date, generate the CMake cache to refresh.."
5. Everything works perfectly now; the "Select Startup Item" menu button should be available to select, compile and execute the target/s specified from the CMakeLists.txt files. Other CMake buttons should now be available, (e.g. Project -> Configure Cache)
6. Quit Visual Studio
7. Open the project again in Visual Studio
8. There does not appear to be a way to restore the working state, Visual Studio does not know the CMake targets anymore, we can no longer compile the project, nor run it. There appears no way to cause Visual Studio to reconfigure within the UI. The existing targets may appear, but no longer work.

I have then followed the tutorial for remote cache: https://devblogs.microsoft.com/cppblog/open-existing-cmake-caches-in-visual-studio/

Doing the steps:

1. Replace configuration 'Linux-GCC-Debug' with 'Existing Cache (Remote)'
2. Update cacheRoot to the path that contains CMakeCache.txt on the remote system

The regenerate popup shows ( "C++ IntelliSense information may be out of date, generate the CMake cache to refresh.." ), pressing regenerate works the first time, but then subsequent re openings of the project result in nothing happening again. No targets / executables to choose.

This issue does not occur for local MSVC CMake projects, the available targets are always shown immediately upon relaunch, along with all other Project settings being available in the UI.

Is this a bug in Visual Studio, or, is there something I'm missing so that Visual Studio always uses the existing cache to configure itself to make the targets available for compiling and executing, whenever I launch the existing project? How do IDE's typically detect CMake targets, perhaps knowing this could give a hint on solving the issue.

Visual Studio Version: 17.0.5

Docker File:

Intel recommends using instruction prefixes to mitigate the performance consequences of JCC Erratum.

MSVC if compiled with /QIntel-jcc-erratum follows the recommendation, and inserts prefixed instructions, like this:

C# string's Splice method seems to copy remnants into an array of strings instead of just reading them. Is there a c++17 string_view equivalent to bypass copying?

For those not familiar with string_view, here is some background information.

From Microsoft's :

The string_view family of template specializations provides an efficient way to pass a read-only, exception-safe, non-owning handle to the character data of any string-like objects with the first element of the sequence at position zero. (...)

From Microsoft's C++ Team Blog std::string_view: The Duct Tape of String Types:

string_view solves the “every platform and library has its own string type” problem for parameters. It can bind to any sequence of characters, so you can just write your function as accepting a string view:

...

When we define a variable of a built-in type too large to parse, Compiler/IDE (I'm using Visual Studio 2019) warns right away that the range has been violated, even before compiling the project - "integer constant is too large" if we're defining an integer.

I'm using several libraries built through vcpkg (such as civet-web and prometheus-cpp), against my Visual C++ projects. When building x86 all is perfect, in x64 I get a bunch of linker errors:

error LNK2001: unresolved external symbol __CxxFrameHandler4

Searching online all references to this symbol/error are about specific projects, I cannot find what __CxxFrameHandler4 is and what problem this error is highlighting. I don't know if it's a problem with the way vcpkg is building the library, or a problem in my project or how to start looking for a solution.

I did find this blog article but it is in reference to a preview of VS2019, I cannot find any settings related to it: https://devblogs.microsoft.com/cppblog/making-cpp-exception-handling-smaller-x64/

If anyone can explain what this is all about it would be a big help.

Using clang++-11 with libstdc++-11 and clang-tidy-11, I run into failures when linting the code with clang-tidy - namely parsing error when dealing with the well-known sleeper std::this_thread::sleep_for(std::chrono::seconds(1));.

Support for C++20 modules has been recently added in MSVC 16.8. If I'm not mistaken, one of the advantages of using modules is that circular import dependencies are now supported. However, the following test project still fails to compile in the latest version of the Microsoft compiler.

computer.ixx

I've been playing with my own implementation of std::array and noticed libc++'s version uses explicitly defined operators for each of the comparisons (==,!=,<,>,<=,>=). I figured I could simplify my code by implementing C++20's spaceship operator (<=>). However, when I replaced the non-member comparison operators with auto operator<=>(const Array&) const = default; in the struct body, GCC trunk indicated that the function was "implicitly deleted because the default definition would be ill-formed". Some investigation indicated that the raw array member was the culprit.

This webpage indicates that, "The compiler knows how to expand members of classes that are arrays into their lists of sub-objects and compare them recursively." And this SO answer indicates that only copyable arrays participate in the comparison synthesis.

Out of curiousity, I ran the code from the first link on Compiler Explorer. It also fails to compile on gcc trunk. However, clang trunk compiles the code successfully.

So, my question is: which compiler is right? Should the comparison be synthesized for member arrays or not?

According to this post VS2017 supports color highlighting for both CMakeLists.txt as well as files with .cmake extension. In my projects Intellisense is not scanning and highlighting .cmake files. Is there a setting which needed to be set for this?