{"id":12685,"date":"2017-02-22T15:08:30","date_gmt":"2017-02-22T22:08:30","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/?p=12685"},"modified":"2019-02-18T17:48:42","modified_gmt":"2019-02-18T17:48:42","slug":"learn-c-concepts-with-visual-studio-and-the-wsl","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/learn-c-concepts-with-visual-studio-and-the-wsl\/","title":{"rendered":"Learn C++ Concepts with Visual Studio and the WSL"},"content":{"rendered":"

\u70b9\u8fd9\u91cc\u770b\u4e2d\u6587\u7248<\/a><\/p>\n

Concepts promise to fundamentally change how we write templated C++ code. They’re in a Technical Specification (TS) right now, but, like Coroutines, Modules, and Ranges, it’s good to get a head start on learning these important features before they make it into the C++ Standard. You can already use Visual Studio 2017 for Coroutines, Modules, and Ranges through a fork of Range-v3<\/a>. Now you can also learn Concepts in Visual Studio 2017 by targeting the Windows Subsystem for Linux (WSL). Read on to find out how!<\/p>\n

About concepts<\/h4>\n

Concepts enable adding requirements to a set of template parameters, essentially creating a kind of interface. The C++ community has been waiting years for this feature to make it into the standard. If you’re interested in the history, Bjarne Stroustrup has written a bit of background about concepts in a recent paper about designing good concepts<\/a>. If you’re just interested in knowing how to use the feature, see Constraints and concepts on cppreference.com<\/a>. If you want all the details about concepts you can read the Concepts Technical Specification (TS)<\/a>.<\/p>\n

Concepts are currently only available in GCC 6+. Concepts are not yet supported by the Microsoft C++ Compiler (MSVC) or Clang. We plan to implement the Concepts TS in MSVC but our focus is on finishing our existing standards conformance work and implementing features that have already been voted into the C++17 draft standard. <\/p>\n

We can use concepts in Visual Studio 2017 by targeting the Linux shell running under WSL. There’s no IDE support for concepts–thus, no IntelliSense or other productivity features that require the compiler–but it’s nice to be able to learn Concepts in the same familiar environment you use day to day. <\/p>\n

First we have to update the GCC compiler. The version included in WSL is currently 4.8.4–that’s too old to support concepts. There are two ways to accomplish that: installing a Personal Package Archive (PPA) or building GCC-6 from source. <\/p>\n

But before you install GCC-6 you should configure your Visual Studio 2017 install to target WSL. See this recent VCBlog post for details: Targeting the Windows Subsystem for Linux from Visual Studio<\/a>. You’ll need a working setup of VS targeting Linux for the following steps. Plus, it’s always good to conquer problems in smaller pieces so you have an easier time figuring out what happened if things go wrong.<\/p>\n

Installing GCC-6<\/h4>\n

You have two options for installing GCC-6: installing from a PPA or building GCC from source. <\/p>\n

Using a PPA to install GCC<\/h5>\n

A PPA allows developers to distribute programs directly to users of apt. Installing a PPA tells your copy of apt that there’s another place it can find software. To get the newest version of GCC, install the Toolchain Test PPA<\/a>, update your apt to find the new install locations, then install g++-6.<\/p>\n

\nsudo add-apt-repository ppa:ubuntu-toolchain-r\/test\nsudo apt update\nsudo apt install g++-6\n<\/pre>\n
The PPA installs GCC as a non-default compiler. Running g++ --version<\/code> shows version 4.8.4. You can invoke GCC by calling g++-6<\/code> instead of g++<\/code>. If GCC 6 isn’t your default compiler you’ll need to change the remote compiler that VS calls in your Linux project (see below.)<\/p>\n
\ng++ --version\ng++-6 --version\n<\/pre>\n
Building GCC from source<\/h5>\n
Another option is to build GCC 6.3 from source. There are a few steps, but it’s a straightforward process. <\/p>\n
    \n
  1. First you need to get a copy of the GCC 6.3 sources<\/a>. Before you can download this to your bash shell, you need to get a link to the source archive. Find a nearby mirror<\/a> and copy the archive’s URL. I’ll use the tar.gz<\/code> in this example:\n
    \nwget http:\/\/[path to archive]\/gcc-6.3.0.tar.gz\n<\/pre>\n<\/li>\n
  2. \nThe command to unpack the GCC sources is as follows (change \/mnt\/c\/tmp<\/code> to the directory where your copy of gcc-6.3.0.tar.gz is located):<\/p>\n
    \ntar -xvf \/mnt\/c\/tmp\/gcc-6.3.0.tar.gz\n<\/pre>\n<\/li>\n
  3. \nNow that we’ve got the GCC sources, we need to install the GCC prerequisites. These are libraries required to build GCC. (See Installing GCC, Support libraries<\/a> for more information.) There are three libraries, and we can install them with apt:<\/p>\n
    \nsudo apt install libgmp-dev\nsudo apt install libmpfr-dev\nsudo apt install libmpc-dev\n<\/pre>\n<\/li>\n
  4. \nNow let’s make a build directory and configure GCC’s build to provide C++ compilers:<\/p>\n
    \ncd gcc-6.3.0\/\nmkdir build\ncd build\n..\/configure --enable-languages=c,c++ --disable-multilib\n<\/pre>\n<\/li>\n
  5. \nOnce that finishes, we can compile GCC. It can take a while to build GCC, so you should use the -j<\/code> option to speed things up. <\/p>\n
    \nmake -j\n<\/pre>\n
    Now go have a nice cup of coffee (and maybe watch a movie) while the compiler compiles. \n<\/li>\n
  6. If make<\/code> completes without errors, you’re ready to install GCC on your system. Note that this command installs GCC 6.3.0 as the default version of GCC. \n
    \nsudo make install\n<\/pre>\n
    You can check that GCC is now defaulting to version 6.3 with this command:<\/p>\n
    \n$ gcc --version\ngcc (GCC) 6.3.0\nCopyright (C) 2016 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n<\/pre>\n<\/li>\n<\/ol>\n
    Trying out Concepts in VS<\/h4>\n
    Now that you’ve updated GCC you’re ready to try out concepts! Let’s restart the SSH service again (in case you exited all your bash instances while working through this walkthrough) and we’re ready to learn concepts!<\/p>\n
    \nsudo service ssh start\n<\/pre>\n
    Create a new Linux project in VS:<\/p>\n
    \"newlinuxproject\"<\/a><\/p>\n
    Add a C++ source file, and add some code that uses concepts. Here’s a simple concept that compiles and executes properly. This example is trivial, as the compile would fail for any argument i<\/code> that doesn’t define operator==<\/code>, but it demonstrates that concepts are working. <\/p>\n
    \n#include <iostream>\n\ntemplate <class T>\nconcept bool EqualityComparable() {\n\treturn requires(T a, T b) {\n\t\t{a == b}->bool;\n\t\t{a != b}->bool;\n\t};\n}\n\nbool is_the_answer(const EqualityComparable& i) {\n\treturn (i == 42) ? true : false;\n}\n\nint main() {\n\tif (is_the_answer(42)) {\n\t\tstd::cout << "42 is the answer to the ultimate question of life, the universe, and everything." << std::endl;\n\t}\n\treturn 0;\n}\n<\/pre>\n
    You’ll also need to enable concepts on the GCC command line. Go to the project properties, and in the C++ > Command Line box add the compiler option -fconcepts<\/code>.<\/p>\n
    \"fconcepts\"<\/a><\/p>\n
    If GCC 6 isn’t the default compiler in your environment you’ll want to tell VS where to find your compiler. You can do that in the project properties under C++ > General > C++ compiler by typing in the compiler name or even a full path:<\/p>\n
    \"gplusplus6\"<\/a><\/p>\n
    Now compile the program and set a breakpoint at the end of main<\/code>. Open the Linux Console so you can see the output (Debug > Linux Console). Hit F5 and watch concepts working inside of VS!<\/p>\n
    \"concepts\"<\/a><\/p>\n
    Now we can use Concepts, Coroutines, Modules, and Ranges all from inside the same Visual Studio IDE!<\/p>\n
    Example: concept dispatch<\/h4>\n
    The example above shows that concepts compile properly but it doesn’t really do anything. Here’s a more motivating example from Casey Carter that uses a type trait to show concept dispatch. This is a really great example to work through to illustrate the mechanics of constraints. <\/p>\n
    \n#include <iostream>\n#include <type_traits>\n\ntemplate<class T>\nconcept bool Integral = std::is_integral<T>::value;\n\ntemplate<class T>\nconcept bool SignedIntegral = Integral<T> && T(-1) < T(0);\n\ntemplate<class T>\nconcept bool UnsignedIntegral = Integral<T> && T(0) < T(-1);\n\ntemplate<class T>\nvoid f(T const& t) {\n    std::cout << "Not integral: " << t << '\\n';\n}\n\nvoid f(Integral) = delete;\n\nvoid f(SignedIntegral i) {\n    std::cout << "SignedIntegral: " << i << '\\n';\n}\n\nvoid f(UnsignedIntegral i) {\n    std::cout << "UnsignedIntegral: " << i << '\\n';\n}\n\nint main() {\n    f(42);\n    f(1729u);\n    f("Hello, World!");\n    enum { bar };\n    f(bar);\n    f('a');\n    f(L'a');\n    f(U'a');\n    f(true);\n}\n<\/pre>\n
    In closing<\/h4>\n
    As always, we welcome your feedback. Feel free to send any comments through e-mail at visualcpp@microsoft.com<\/a>, through Twitter @visualc<\/a>, or Facebook at Microsoft Visual Cpp<\/a>. <\/p>\n
    If you encounter other problems with Visual C++ in VS 2017 please let us know via the Report a Problem<\/a> option, either from the installer or the Visual Studio IDE itself. For suggestions, let us know through UserVoice<\/a>. Thank you!<\/p>\n","protected":false},"excerpt":{"rendered":"
    \u70b9\u8fd9\u91cc\u770b\u4e2d\u6587\u7248 Concepts promise to fundamentally change how we write templated C++ code. They’re in a Technical Specification (TS) right now, but, like Coroutines, Modules, and Ranges, it’s good to get a head start on learning these important features before they make it into the C++ Standard. You can already use Visual Studio 2017 for Coroutines, […]<\/p>\n","protected":false},"author":312,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[279],"tags":[],"class_list":["post-12685","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux"],"acf":[],"blog_post_summary":"
    \u70b9\u8fd9\u91cc\u770b\u4e2d\u6587\u7248 Concepts promise to fundamentally change how we write templated C++ code. They’re in a Technical Specification (TS) right now, but, like Coroutines, Modules, and Ranges, it’s good to get a head start on learning these important features before they make it into the C++ Standard. You can already use Visual Studio 2017 for Coroutines, […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/12685","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/312"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=12685"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/12685\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=12685"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=12685"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=12685"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}