{"id":15255,"date":"2017-04-21T20:45:28","date_gmt":"2017-04-21T20:45:28","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/?p=15255"},"modified":"2020-12-09T17:06:06","modified_gmt":"2020-12-09T17:06:06","slug":"getting-started-with-visual-studio-for-c-and-cpp-development","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/getting-started-with-visual-studio-for-c-and-cpp-development\/","title":{"rendered":"Getting Started with Visual Studio for C and C++ Development"},"content":{"rendered":"

Are you new to Visual Studio and working with C++? Then you\u2019ve come to the right place. Whether you\u2019re a student writing one of your first programs or a seasoned C++ developer with years of experience, you’ll find Visual Studio to be a powerful environment for C++ development. Visual Studio is an IDE packed with features, from code browsing, colorization and navigation, to autocompletion of symbols, a built-in compiler and build system, a top of the line debugger, and built-in testing and code analysis tools. We have you covered from beginning to end, from code inception to continuous integration management, but of course this means there is a lot to learn. This blog post breaks down the basics to get you started. You will get only a small glimpse of the powerful tools that Visual Studio provides, but if you want to learn more, you should click the links throughout this post.<\/p>\n

This blog post goes over the following concepts:<\/p>\n

    \n
  1. Setting Up Visual Studio<\/a><\/li>\n
  2. Opening Projects or Folders of Code<\/a><\/li>\n
  3. Building the Application<\/a><\/li>\n
  4. Code Editing & Navigation<\/a><\/li>\n
  5. Debugging and Diagnosing Issues<\/a><\/li>\n
  6. Testing<\/a><\/li>\n
  7. Working With A Team<\/a><\/li>\n
  8. Other Topics<\/a><\/li>\n
  9. Conclusion<\/a><\/li>\n<\/ol>\n

    <\/a><\/p>\n

    Setting Up Visual Studio<\/h4>\n

    Visual Studio crossed the 20-year mark with the release of Visual Studio 2017<\/em>. There are many versions of the product out there, but in general, you should always pick the latest one. This will allow you to use the latest and greatest features, including the most up-to-date compiler. You’ll also benefit from recent bug fixes and performance improvements.<\/p>\n

    Visual Studio is available in three different editions: Community<\/em>, Professional<\/em>, and Enterprise<\/em>. The Community Edition<\/a> is completely free of charge for small businesses, open source projects, academic research, and classroom learning environments. If you don\u2019t qualify for the Community License, you can purchase the Professional Edition instead. If you work for a large enterprise or simply want the best Visual Studio has to offer, then you should consider the Enterprise Edition. You can compare the offerings<\/a> on the Visual Studio website if you are unsure. This guide is applicable to all editions. <\/p>\n

    Download the latest Visual Studio<\/a><\/strong><\/p>\n

    Once you have downloaded the installer, run it. Visual Studio allows you to choose what workloads <\/a>you want to install, choosing only the components you want, and nothing you don\u2019t. The following workloads are under the C++ umbrella:<\/p>\n\n\n\n\n\n\n
    \"Desktop<\/a><\/td>\nDesktop development with C++<\/a><\/strong>\nProvides the tools needed for building and debugging classic desktop applications. This includes classic Win32 console applications.<\/td>\n<\/tr>\n
    \"Mobile<\/a><\/td>\nMobile development with C++<\/a><\/strong>\nIncludes the tools needed for targeting Android and iOS.<\/td>\n<\/tr>\n
    \"Game<\/a><\/td>\n\nGame development with C++<\/a><\/strong>\nEnables you to quickly and easily get started building games using DirectX, Unreal Engine, or Cocos2d.<\/td>\n<\/tr>\n
    \"Linux<\/a><\/td>\nLinux development with C++<\/strong><\/a>\nAll the necessary tools for developing and debugging Linux applications.<\/td>\n<\/tr>\n
    \"UWP<\/a><\/td>\nUniversal Windows Platform development<\/strong><\/a>\nThis workload is not specific to just C++, but you can enable the C++ support by checking the individual component for \u201cC++ UWP support\u201d.<\/td>\n<\/tr>\n<\/table>\n

    There are a variety of other workloads for other languages such as C#, and other platforms such as Microsoft Azure (for your cloud needs). The workloads you install are not permanent, and you can always change these options by opening the installer and selecting Modify<\/em>. <\/p>\n

    For this guide, please install the Desktop development with C++ workload. <\/strong>\n\"Installer<\/a><\/p>\n

    Once you have made your selection and clicked Install<\/em>, Visual Studio will begin the installation process. Once it is complete, Visual Studio is all set up and ready to go!<\/p>\n

    Now let\u2019s look at an actual project. For this next section, if at any time, you cannot find some feature or command that you are looking for, you can search for it via Quick Launch<\/strong><\/em>, the search box at the upper right of the IDE (or press Ctrl+Q<\/em> to get there fast).<\/p>\n

    Download the demo project<\/strong><\/a><\/p>\n

    <\/a><\/p>\n

    Opening Projects or Folders of Code<\/h4>\n

    If you open the demo project folder in Windows File Explorer, you will find a variety of different files in addition to some source code. Generally, code organized by Visual Studio appears as a Solution, which contains a collection of Projects. When a codebase is organized this way, it includes a .sln<\/em> file (which configures the solution) as well as .vcxproj<\/em> files (which configure each project); these files help define things like include paths, compiler settings, and how the projects are connected. <\/p>\n

    Visual Studio also supports an Open Folder mode<\/a> as of Visual Studio 2017 which does away with .sln and .vcxproj files and allows you as the user to configure your own environment independently. This approach is ideal for cross-platform projects that will be run from a variety of different IDEs or editors. Better yet, if you are a CMake user, as of Visual Studio 2017 there is a built-in CMake experience<\/a>. This guide will not go over Open Folder or CMake, but you are encouraged to check out the relevant blog posts linked in this paragraph for more information. <\/p>\n

    To open demoApplication<\/strong><\/em>, double click the .sln<\/strong><\/em> file, or from Visual Studio go to File > Open > Project\/Solution…<\/em> and navigate to the appropriate solution. <\/strong><\/p>\n

    Once you have opened the project, a view of the content in the project will appear in the Solution Explorer<\/strong><\/em>, pictured below:\"Solution<\/a>\nNew projects can be also created by going to File > New > Project…<\/em> and selecting the template that is appropriate. Console applications are under Visual C++ > Win32<\/em>.\n<\/a><\/p>\n

    Building the Application<\/h4>\n

    Visual Studio is closely integrated with the Visual C++ compiler, which makes it easy to build and debug your C++ applications. Near the top of the IDE inside the standard toolbar, there are dropdowns where you can change your build configuration and architecture. You can also easily add more configurations, as needed. For this exercise, you can leave the default settings of Debug <\/em>and x86<\/em>.\n\"Project<\/a>\nAttempt to build the application by going to Build > Build Solution<\/strong><\/em> (or alternatively by pressing F7<\/strong><\/em>). The build will fail, since the code contains an error.<\/strong>\nThe Output Window<\/strong><\/em> is a valuable tool while you are building; it provides information about the status of the build.\n\"Output<\/a><\/p>\n

    Fixing compiler errors<\/h5>\n

    You should see an error in the Error List<\/strong><\/em> at the bottom of the screen when you attempt to build. With this error, you not only get the location of the problem and a description, but if you double-click the line, you will be brought to the specific location in the code. This makes it easy to quickly navigate to problem areas. <\/p>\n

    Double-click on the error after building, and fix the offending line of code. <\/strong>\n<\/a><\/p>\n

    Code Editing & Navigation<\/h4>\n

    This section provides a glimpse of what is possible in Visual Studio. To learn more about this area please visit the C++ Code Editing and Navigation in Visual Studio<\/a> blog post. <\/p>\n

    Intellisense<\/h5>\n

    One of the most useful features for helping you write code quickly in Visual Studio is IntelliSense<\/strong><\/em>, which is a context-aware code completion tool. As you type, Visual Studio will suggest classes, methods, objects, code snippets, and more symbols that make sense in relation to what you have typed so far and where you have typed it. You can scroll up and down the suggestions with the arrow keys<\/em>, and complete symbols with Tab<\/em>.<\/p>\n

    In the main function try adding a call to the farewell <\/strong><\/em>function to the mySorter <\/em>object. You should see IntelliSense <\/em>pop up with all the possible functions available from the sorter <\/em>class. <\/strong>\n\"IntelliSense\"<\/a><\/p>\n

    Go To<\/h5>\n

    To efficiently write and understand code, easy code navigation is essential. By using the Go To<\/strong><\/em> feature (Ctrl+T)<\/em> you can quickly get to where you need to go, without taking your hands off the keyboard. When you open the dialog, you can filter your results by clicking on the desired button, or by starting your query with a specific token. For example, you can go to a specific file by opening the Go To <\/em>dialog and typing \u201cf <\/em>\u201d. Another common way to access this dialog is by going to a specific line number; you can do this by opening the menu traditionally and using the \u201c:\u201d token, or by pressing Ctrl+G<\/em>. Try using Go To<\/em> to navigate around the demo project. <\/p>\n

    Use the Go To<\/strong><\/em> menu (Ctrl+T)<\/strong><\/em> to open the file sorter.h<\/strong><\/em> by typing \u201cf sorter.h<\/strong><\/em>\u201d.\nUse the Ctrl+G<\/strong> <\/em>shortcut to go to line 23<\/strong><\/em> to change the private member \u201cname<\/strong><\/em>\u201d to your name. <\/strong>\n\"Go<\/a><\/p>\n

    Peek\/Go to Definition<\/h5>\n

    Sometimes it can be challenging to find out where a function or object is defined in your codebase. This problem is easily solved in Visual Studio, where you can easily peek into definitions. Try this in the demo project by selecting the function you want to look at, and pressing Alt+F12<\/em>, or selecting it from the right-click menu. This will bring up a preview of the file where the function is defined, where you can quickly make small edits. Press Esc <\/em>to close the preview window. You can also go directly to the definition by pressing only F12<\/em>. <\/p>\n

    Use Peek Definition<\/strong><\/em> on the printVector <\/strong><\/em>function by selecting the function and pressing Alt+F12<\/strong><\/em>. <\/p>\n

    Add a dash between the numbers in the vector when they are printed. <\/strong>\n\"Peek<\/a><\/p>\n

    Rename<\/h5>\n

    You can also use Visual Studio to refactor existing code. In the demo project, there is a function that has an unhelpful name. Rather than going to each file to change the name of each occurrence manually, choose one of the functions and press Ctrl+R, Ctrl+R<\/em> or right-click it and choose Rename<\/em>. This will bring up a menu where you can choose what you want to rename it to, and then preview the changes before they are committed. <\/p>\n

    Use Rename (Ctrl+R, Ctrl+R)<\/strong><\/em> to change the method \u201cSILLY_SALUTATION_FUNCTION<\/em>\u201d to something more useful, such as \u201cgreeting<\/em>\u201d.<\/strong>\n\"Rename<\/a>\n<\/a><\/p>\n

    Debugging and Diagnosing Issues<\/h4>\n

    Once you can successfully build your application and write code easily, the next step is often debugging the application. Debugging can be a complex process, and Visual Studio provides many powerful tools to help along the way. The most commonly used debugging tool is the breakpoint<\/strong><\/em>, so let\u2019s start with that. If you click on the bar to the left of your code, a red circle should appear. If you click the circle, the breakpoint will be removed.\n\"Breakpoint\"<\/a>\nWhen a breakpoint is set and the program reaches that point of execution, it will stop, allowing you to inspect variables and the current state of the program. <\/p>\n

    Place a breakpoint on line 33<\/strong><\/em> of demoApplication.cpp<\/em> by clicking the bar to the left of the line numbers. <\/p>\n

    Click the red circle again to remove the breakpoint.<\/strong>\n\"Start<\/a>\nTo begin debugging, you can either press the green arrow at the top of the IDE or press F5<\/em>. Once the program has stopped on the breakpoint<\/em>, there are many things you can do to help you diagnose problems. One of the best ways to find problems is to understand the current state of the program, versus what it should be. This can be easily achieved by using the Autos Window<\/strong><\/em>, which lists recently used variables and their values. You can also hover your mouse over a variable to see what the current value is. <\/p>\n

    Do the following: \n<\/p>\n

      \n
    1. Place a breakpoint on line 14<\/strong> <\/em>of the main <\/strong><\/em>function.<\/li>\n
    2. Click the green arrow at the top of the IDE or press F5<\/strong><\/em> to begin debugging.<\/li>\n
    3. Find out what the value of testInt <\/strong><\/em>is before it is initialized by hovering over the value in the code.<\/li>\n
    4. Look at the value of testInt<\/strong> <\/em>in the Autos window<\/strong><\/em>.<\/li>\n
    5. Press the green arrow or F5 <\/strong><\/em>again to stop debugging.<\/li>\n<\/ol>\n

      <\/strong>\n\"Breakpoint<\/a>\n\"Autos<\/a>\nWhen you have sufficiently understood the current state of the program, you can press the green arrow button or press F5 <\/em>again to have the program run until the next breakpoint. You can also step the program one line at a time if needed by using the arrows at the top.\n\"Stepping\"<\/a>\nStep Over<\/strong><\/em> (F10)<\/em> will run through whatever is on the current line, and suspend execution after the function returns. Step Into<\/strong><\/em> (F11)<\/em> will follow the function call of the next line, allowing you to see what is happening inside that function. At any time, you can step out (Shift+F11)<\/em>, which will place the program just after it has completed the current functional scope. Once you are finished debugging you can run the program to its completion, or press the red square (or Shift+F5<\/em>) at the top of the IDE to stop the debugging session. <\/p>\n

      Use a combination of these to explore the demo project and see if you can fix the logical bug in the sort algorithm (Hint: it is in the sort algorithm itself). <\/strong><\/p>\n

      There are many more tools within Visual Studio that can help you profile and debug your applications. Check out the C++ Debugging and Diagnostics<\/a> blog post to learn more. \n<\/a><\/p>\n

      Testing<\/h4>\n

      Visual Studio has a built-in test framework to help you unit test your projects, ensuring that the code you write is working as expected. To test the demo project, which is a native console application, you can add a Native Unit Test Project<\/em> to the solution. <\/p>\n

      Add a test project to the demo. This is done by going to File > New > Project<\/strong><\/em> then selecting Visual C++ > Test > Native Unit Test Project<\/strong><\/em>. Make sure to choose the Add to solution<\/strong><\/em> option in the Solution dropdown. You can also simply right-click your solution name in the Solution Explorer<\/strong><\/em> and choose Add > New Project<\/strong><\/em> to accomplish the same task. <\/strong>\n\"Create<\/a>\nOnce you have added a unit test, you can open the .cpp<\/em> file and see the basic testing skeleton in the template, and begin to add tests. <\/p>\n

      Add a test method, making sure that it will pass. Try the following code:<\/strong>\nTEST_METHOD(TestMethod1) \n{ \nAssert::AreEqual(1,1); \n} <\/code>\n\"Writing<\/a>\nOnce you have added a test, you can run the test by going to Test > Run > All Tests<\/em> in the menu at the top of the IDE. Once you have run the tests, you will see the results in the Test Explorer<\/strong><\/em> window.<\/p>\n

      Run your test by going to Test > Run > All Tests<\/strong><\/em>. Try adding another test that will fail, and running the tests again. <\/strong>\n\"Test<\/a>\nIf you would like to find out more information about unit testing, including how to connect your test project to your code under test, and check the code coverage of your unit tests, check out the C++ Unit Testing in Visual Studio<\/a> blog post. \n<\/a><\/p>\n

      Working with A Team<\/h4>\n

      It is very common these days to be working on a project with a team, and Visual Studio makes collaboration with others easy! You can easily create new source control repositories using Git <\/em>or Team Foundation Server<\/em> to manage your codebase. To create a new repo for a project, click the Add to Source Control<\/em> button at the bottom of the screen, and add the opened project to the source control system of your choice. \n\"Add<\/a>\nOnce you do that, a local repository will be made for your project. From here you can make commits, or push your changes to a remote Git<\/em> service such as GitHub. This is all managed in the Team Explorer<\/strong><\/em> window.\n\"Team<\/a><\/p>\n

      Try adding the demo project to source control, and pushing it to GitHub. This is done by pressing the Add to source control<\/strong><\/em> button, and then pushing to a remote repository inside the Team Explorer<\/strong><\/em>. <\/strong><\/p>\n

      You can also very easily clone from source control from the Team Explorer<\/em> window. Choose Projects > New Repository<\/em>, and then follow the prompts to clone the project. From here, all you must do is paste in the URL, and the project will be cloned.\n\"Clone<\/a>\n\"Clone<\/a>\nTo learn more about working on a project as a team in Visual Studio, check out the Visual Studio for Teams of C++ Developers<\/a> blog post. \n<\/a><\/p>\n

      Other Topics<\/h4>\n

      There are many other useful things Visual Studio can do. So many things, in fact, it is hard to cover it all in one guide. Follow the links below to find out more on how to get the most out of Visual Studio.<\/p>\n

      Code Analysis<\/h5>\n

      Visual Studio by default catches a lot of code issues, but its Code Analysis<\/strong><\/em> tool can often uncover hard-to-find issues that would normally be missed. Common errors that are reported include buffer overflows, uninitialized memory, null pointer dereferences, and memory and resource leaks. This functionality is built into the IDE, and can easily be used to help you write better code. Try it out by going to the Analyze <\/em>menu and choosing Run Code Analysis > On Solution<\/em>. Learn more about Code Analysis<\/em> as well as the C++ Core Guidelines Checkers in the announcement blog post<\/a>. <\/p>\n

      Library Acquisition<\/h5>\n

      Library acquisition in C++ can be challenging. While Visual Studio has support for NuGet <\/em>package management, more recently a new tool called vcpkg <\/strong><\/em>was launched. Vcpkg <\/em>is an open source tool maintained by Microsoft that simplifies acquiring and building open source libraries, with over 200 currently supported. This tool, while separate from Visual Studio itself, is a valuable companion for any C++ developer on Windows. Check out the announcement blog post<\/a> for details. \n<\/a><\/p>\n

      Conclusion<\/h4>\n

      We hope that this guide has allowed you to get up to speed with Visual Studio quickly, and that you have learned some of the core functionality. This should be enough to get you started, but there are still many more features that could not be covered in this guide. The Visual C++ Blog is a very useful resource to find out more about not only the product overall, but also what we are currently working on and changing. You can find the comprehensive product documentation on docs.microsoft.com<\/a> as well. Now get out there and build something amazing!<\/p>\n

      We are constantly trying to improve, so if you have any feedback or suggestions for us, please feel free to reach out to us anytime! We can be reached via email at visualcpp at microsoft.com<\/em> and you can provide feedback via Help > Report A Problem<\/em> in the product, or via Developer Community<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

      Are you new to Visual Studio and working with C++? Then you\u2019ve come to the right place. Whether you\u2019re a student writing one of your first programs or a seasoned C++ developer with years of experience, you’ll find Visual Studio to be a powerful environment for C++ development. Visual Studio is an IDE packed with […]<\/p>\n","protected":false},"author":326,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-15255","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"

      Are you new to Visual Studio and working with C++? Then you\u2019ve come to the right place. Whether you\u2019re a student writing one of your first programs or a seasoned C++ developer with years of experience, you’ll find Visual Studio to be a powerful environment for C++ development. Visual Studio is an IDE packed with […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/15255","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\/326"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=15255"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/15255\/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=15255"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=15255"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=15255"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}