Visual C++ Quick Start and Quick Reference for Visual Studio

The purpose of this document is to help someone who is
encountering Visual C++ for the first time to get started quickly with
writing C++ programs using the programming environment provided by the
latest Visual Studio IDE (Integrated
Development Environment).

Suggestions for additional material to be included on this page are
always welcome.

Overview

Visual Studio allows you to write many different kinds of C++
software, from simple console programs to DLLs (Dynamic Link Libraries)
to Active Template Library Components to the usual kinds of Windows GUI
applications that we use all the time. There is no need to worry if you
don’t know what some of these things are, since you will (probably) be
writing console programs for the foreseeable future. A console
program is one that has a simple (old-fashioned, if you like) text-based
interface, in which program output appears on lines that scroll upward to
the top of, and eventually off, the screen. We use such programs so that
we can concentrate on data structures, algorithms, and C++ itself, without
being distracted by the time and energy it takes to deal with a graphical
user interface, which adds little if anything to our main interests in this
course.

Whenever you do something in the Visual Studio version of C++ (Visual
C++), you will generally do it within the framework of a single
project within your solution, though a solution
may actually contain several projects if that is appropriate.
Whatever projects you’ve been working on are noted by Visual Studio, and
you are presented with a list of the most recent ones via the Recent
Projects pane on the Start Page whenever you fire up Visual Studio.
[However, although this will be the case for Visual Studio on your home
computer, it may not happen if you are using Visual Studio in a
strictly controlled networked environment where some settings (such as
this one) may be set back to their initial default values according to
some schedule set by the network administrators.]

Visual Studio does its best to help you out when you’re working.
Sometimes this can be pleasant and useful. Other times it can be
downright unpleasant and frustrating. It can also be quite overwhelming,
when you find, for example, that quite a number of files you know nothing
about have been created for you. Ignoring these extra files is usually
the best thing to do.

So, it is important to have a good sense of the big picture, and not
to be overwhelmed or intimidated by all the minutiae that need not
concern you, at least not in the short term.

Getting Started: Creating, Building, and Running a New “Win32 Console
Application”

Here, in very brief form, is the sequence of steps necessary to start
a new project, enter a single source code file, and then build and run
the executable:

  1. Start Visual Studio from the appropriate place in your Windows
    environment. After a (short, you hope) wait, among the things you will
    see on your screen will be a “Start Page” window in the center of your
    screen containing several smaller panes, which may vary, depending on
    how Visual Studio actually opens.
  2. You should be able to choose New Project … under Start,
    or choose File | New | Project under the File menu.
  3. In the “New Project” window that opens up, make sure you choose the Visual C++ |
    Win32 | Win32 Console Application option. Then enter the name of your project in the “Name:”
    box (“Test”, for example). The “Location:” box may contain the path you
    want, and if so you can just leave it. Otherwise, you will need to
    enter the full path to the location where you want your project to be
    stored. (You may also want to make a note of this location, so that you
    can look there later to see what files have been created.) Next, be
    sure to uncheck the “Create directory for solution” box if it
    is checked. [The
    reason for this is that you are only creating a single project, not a
    “solution” to contain several projects.] Now you may click OK.
  4. A “Win32 Application Wizard” window opens up. Click on “Application
    Settings”, and make sure the “Empty project” box is checked. Then click
    the “Finish” button. (Now is a good time to go to Windows Explorer and
    check to see what files have shown up in the location identified in the
    “Location:” box in the above step.)
  5. At this point your “Solution Explorer” window will contain, among
    other things, an icon labeled by the name of your project. If so, your
    project has been set up but doesn’t contain any source code yet.
  6. Under the “Project” menu choose “Add new item…” (or press
    Ctrl+Shift+A). In the “Add New Item” window that opens up, choose
    Visual C++ | Code | C++ file (.cpp). On the
    other hand, if you already have a program file that you wish to add to
    your project, rather than write a new one, you should choose “Add
    Existing Item…” at the beginning of this step.
  7. Now, in the “Name:” box enter a name for your file. If this is to
    be the file which contains the main function for your
    project, you may want to give it the same name as the project, but this
    is by no means necessary. You do not need to add .cpp to the name,
    since Visual Studio knows this is a C++ file and will add it for
    you.
  8. Now click the “Add” button and an editing window will open, into
    which you may enter the source code for your program. If this is your
    first time through, try the code for a simple “Hello, world!”
    program.
  9. When you are ready to try a build, go to the “Build” menu and
    choose “Build Solution” (or press Ctrl+Shift+B, or click on the “Build
    icon” of the “Build toolbar” if that toolbar is displayed). Your source
    code file is automatically saved to disk before the build. The “Output
    Window” will open and display the results of your build, including any
    compile-time or other errors that have shown up in the attempt to build
    your solution. Note that if you have made an error and have to make
    source code changes, the changes you made are again automatically saved
    to disk when you choose to rebuild. You can double click on any error
    line to show where that error has occurred in your source code, or
    press F1 when the line is highlighted in the “Output Window” to get
    more information from the Help system on the error reported in that
    line.
  10. If the build is successful, an executable file with the same name
    as the project and a .exe extension will have been created in the Debug
    subdirectory. Next, go to the Debug menu and choose “Start without
    debugging” (or press Ctrl+F5) to run your program. (Actually, you can
    go here directly before the build step, and the build step will be done
    before the run.) A console window should open and your program should
    run in it. The IDE supplies its own pause at the end of your program,
    but it is usually a good idea to place a pause of your own at the end
    of each of your programs. If you don’t, and you run that executable by
    double clicking on it in Windows, you may not see all of the output
    from your program, since the console window that Windows Explorer opens
    will disappear the moment your program ends.
  11. Once you have finished to this point, you may remove the first file
    from your project and add a new one, you may close down the current
    project and create another project, or you may shut down Visual Studio
    itself.

Running your program outside Visual Studio

Once you have a working executable, you can run the program
independently of Visual C++ in the following two ways:

  • You can double-click on the executable file while in Windows
    Explorer. Once again, remember that without a pause at the end of your
    program you may “miss” all or part of the output, since Windows
    Explorer does not supply that “Press any key to continue” facility that
    appears at the end of the Visual C++ IDE console window when a console
    program is run.
  • You may also open a console window yourself (by choosing Start |
    Run, entering cmd and pressing Enter, for example) and
    then run the program directly from the command line, in the “usual”
    way.

Working with Files in a Project

Once you have added to your
project all the files the project needs, you may perform any of the
following actions.

  1. Double click on the name of a source code file in the “Solution
    Explorer” window to display it in the text editor window.
  2. Place the cursor in the word “include” (of any #include line),
    right click, and then choose “Open Document” to view that particular
    header file in the text editor window. Notice how a “name tab” appears
    for each “window” that opens up in the text editor, above the text of
    the currently active window. Just clicking on any such tab will make
    the corresponding window active.
  3. Press Ctrl+F5 at any time to run the current executable. If it has
    not yet been built, or if changes have been made in the source code,
    you will be prompted to (re)build before running. Note again that files
    are saved to disk as part of the build process.
  4. Choose “Rebuild Solution” from the Build menu at any time if you
    wish to re-build everything for any reason (whether it has changed or
    not).
  5. Press Ctrl+F7 if you just want to compile the source code file in
    the active window, but not build an executable.
  6. A potentially confusing situation occurs if your program itself
    reads from a data file: In this case, the IDE expects that file to be
    in your project directory, even though the executable is in a
    subdirectory called Debug in your project directory. Such a data file
    does not have to be added to the project, so long as it is present and
    in the right location. On the other hand, if you are running your
    program from Windows Explorer, or from the command prompt in a console
    window, your program and the data file from which it reads must be in
    the same directory, unless you supply to your program the full path to
    a file in some other location.
  7. To remove a file from the current project, click on the file in the
    “Solution Explorer” window and press the Delete key. In the window that
    opens up be sure to choose the “Remove” option to delete that file from
    the current project (though not from its physical location on
    disk). If you really do want to delete the file entirely in addition to
    removing it from the project, choose the “Delete” option.

The Text Editor: Creating and Modifying Source Code Files

The first thing to know about the Visual Studio text editor is that
many of the “usual” commands for navigation and applying changes to text
that are familiar to users of other Microsoft products (such as Word)
also work here, and (mercifully) in the same way. Hence, assuming this
familiarity, we shall not give the details of those commands here. It is
therefore assumed that you are familiar with what the following keyboard
commands do for you when editing text: the four arrow keys, Home, End,
Ctrl+Home, Ctrl+End, PageUp, PageDown (and using the Shift key with any
of these motion commands to select text), as well as Ctrl+C, Ctrl+X,
Ctrl+V, Ctrl+A, and Ins.

We list below some commands and features that are either not present
in other applications, or are not as widely known or used, but which you
may find useful in the Visual Studio Visual C++ environment:

  1. Let the editor’s “smart autoindent” feature work for you. It knows,
    for the most part, how your code should be formatted, and you should
    let it decide, for example, things like what the indent level should be
    (4 spaces), and the proper placement of braces. This feature should be
    on by default. In fact, you can select a section of code that has had
    its formatting “messed up”, or is not formatted quite right, and have
    the whole thing properly formatted for you automatically by pressing
    Ctrl+K, then Ctrl+F.
  2. If a group of contiguous lines of code need to be indented or
    unindented one or more levels, select those lines of code and then
    press the TAB key to indent them an additional level, or the Shift+TAB
    combination to “unindent” them one level.
  3. It is a good idea to have no TAB characters in your file.
    You can remove all TAB characters from a file at any time by selecting
    your entire file with Ctrl+A and then choosing Edit | Advanced |
    Untabify Selection. Ideally, your default setting should be to have
    spaces inserted into your file when you press the TAB key.
  4. Ctrl+R, then Ctrl+W toggles the display of whitespace in your
    source code. Blank spaces show up as a dot, while each Tab character
    shows up as a small rightward-pointing arrow (->). This is a great
    help when you want to check whether in fact you have removed
    all the tabs from your source code, or any other document.
  5. To set Visual Studio itself to handle Tab characters in the
    appropriate way, go to Tools | Options | Text Editor | C/C++ | Tabs and
    set “Indenting” to “Smart”, both “Tab size:” and “Indent size:” to 4,
    and activate “Insert spaces” rather than “Keep tabs”. With these
    settings you should never have to “untabify” your code again, since
    spaces will automatically be inserted whenever you press the TAB key,
    and your indentation levels will always be 4. These settings must of
    course be compatible with whatever programming style conventions you
    are using.
  6. Double-clicking on the little rectangular box above the up-arrow at
    the top of the scroll-box region at the right of the text editor window
    will split the current window into two equal parts, one above the
    other, as will choosing “Split” from the “Window” menu. This gives you
    two views of the same file, which can be scrolled and edited
    independently. Double-clicking on the separating bar will return you to
    a single window, as will choosing “Remove Split” from the “Window”
    menu.
  7. Ctrl+K, then Ctrl+K toggles an unnamed bookmark at the cursor line,
    and Ctrl+K, then Ctrl+N moves to the next bookmark, while Ctrl+K, then
    Ctrl+P moves to the previous bookmark. Ctrl+K, then Ctrl+L clears all
    bookmarks in the current window.
  8. Ctrl+G allows you to go to various locations, including (probably
    most usefully) a particular line number.
  9. When the cursor is on either side of a bracket (round, square,
    curly, or angle), Ctrl+] will place the cursor on the matching bracket
    symbol.
  10. Ctrl+U/Ctrl+Shift+U converts selected text to lower/upper
    case.
  11. To change the font size, choose “Tools | Options | Environment |
    Fonts and Colors”, and then choose your desired size in the “Size:”
    box.
  12. You can toggle a source file window between its regular size and a
    full screen with either the menu command View | Full Screen, or
    Shift+Alt+Enter. Even in full screen mode, a menu bar is retained at
    the top of the window.
  13. Ctrl+Z undoes the previous change. Pressing it again undoes the
    change before that, and so on. If you undo one change to many, you can
    “re-do” the last undo with a Ctrl+Y.
  14. Clicking in the blank area to the left of the a line in the edit
    window selects that line.
  15. Tab/Shift+Tab indent/unindent selected text one level of
    indentation.
  16. Ctrl+Tab cycles through the queue of open windows, much like
    Alt+Tab does in Windows itself.
  17. Ctrl+F opens a Find dialog box for entry of a search string, after
    which F3/Shift+F3 find the next/previous instances. Esc gets you out of
    Find and back to the source code window.
  18. Ctrl+F3 will start a search for selected text.
  19. Ctrl+H starts a Find/Replace.
  20. Ctrl+I starts and “incremental search”, i.e., a search that starts
    as soon as you begin typing and looks for the first instance of as much
    as you have typed in so far, and Ctrl+Shift+I starts a similar
    backwards search.
  21. Ctrl+Shift+T interchanges the current and following words, while
    Alt+Shift+T interchanges the current and following lines.
  22. Ctrl+Delete deletes from the cursor up to but not including the
    first character of the next word to the right. Ctrl+Backspace deletes
    from the cursor back to, and including, the nearest character to the
    left that appears as the first character of a word.
  23. Ctrl+L deletes the current line and places it on the clipboard,
    Ctrl+Shift+L deletes it without placing on the clipboard (i.e., it’s
    gone).
  24. Ctrl with the arrow keys provides some useful commands:
    Ctrl+RightArrow moves the cursor to the beginning of the next word,
    while Ctrl+LeftArrow moves the cursor to the beginning of the previous
    word. Ctrl+UpArrow scrolls the window down one line, while
    Ctrl+DownArrow scrolls the window up one line, with the insertion point
    remaining fixed in both cases.
  25. Ctrl+K, then Ctrl+C will “comment out” any lines you have selected,
    while Ctrl+K, then Ctrl+U will remove the comments from selected lines
    commented out with C++ style comments.
  26. Visual Studio has a number of other useful features that we will
    not describe in detail here. We do mention them, however, since you
    should at least know about them, and do your best to explore their
    possibilities, as needed, in the course of your program development:

    • the “Task Window”, which generally pops up, along with the
      “Output Window”, when you build a project, and can be useful in
      tracking and/or annotating problems, or things-to-do, related to
      your project
    • “Outlining” of source code (see under Edit | Outlining), which
      allows you to alternately collapse and expand selected sections of
      code in your editing window
    • the “Clipboard Ring”, which may be helpful if you have some
      complicated cutting and pasting you want to do
    • the display of line numbers, on the screen and/or on a
      hard-copy printout of your code
    • By default your “Working Directory” is your project directory.
      This means that this is where the IDE looks for certain things,
      such as an input data file from which your program expects to read
      data, as well as files your program includes via #include
      directives. You may change the working directory by going to
      Properties | Configuration Properties | Debugging
      and
      entering the path to the desired working directory in the
      Working Directory box.

Debugging

As your programs get more complex, you may from time to time want (or
need) to use the Visual C++ debugger to help you track down a run-time
error or see where your program is going astray as it executes. When you
start debugging, a number of windows will open automatically. It may be
useful to explore the various options that are available to you for
viewing, and for other actions, via these windows. Here is a brief list
of some debugger commands:

  1. Choose your break points, which can be toggled on and off, either
    by pressing F9, or by clicking in the grey vertical bar to the left of
    the code, when the cursor is on the code line at which you wish to
    break during a run.
  2. Start debugging by choosing Debug | Start, or by simply pressing
    F5.
  3. Press F10 to step through your code a line at a time (without going
    into functions, which may be what you need most of the time), or F11 to
    step through your code, including the internal code of functions.
  4. To skip over some code place the cursor at the point to which you
    would like to go without stopping and then press Ctrl+F10 to “run to
    the cursor”.
  5. Press Shift+F5 to stop debugging and Ctrl+Shift+F5 to restart.

Useful Miscellaneous Information

  1. An editor macro is like a C++ function (or C++ macro, for
    that matter) that can be called upon to perform a specific task. A
    number of editor macros may be available for your use, and, if
    so, they will be described elsewhere.
  2. If your program uses command-line parameters and you are testing it
    with the IDE, in the “Solution Explorer” window select your project,
    right click and choose “Properties”. In the “Property Pages” window
    that opens, choose Configuration Properties | Debugging and then enter
    your command line arguments in the “Command Arguments:” box.
  3. If your program uses RTTI (which stands for Run-Time Type
    Identification, or Run-Time Type Information, depending on where you
    read about it), this feature may need to be “turned on”. To do this,
    first right click on the name of your project in the “Solution
    Explorer” window and then choose “Properties”. In the “Property Pages”
    window which appears, choose “C/C++” and then “Language”. One of the
    lines in the sub-window that then appears is labeled “Run-Time Type
    Info”, and this option must be set to Yes.
  4. When you start using C++ with Visual Studio, you may get some
    (or a lot) of “Warning” messages at compile time that you are not used
    to seeing, particularly if you are using the STL. These warnings will
    be numbered, and if you know that whatever the “problem” is truly will
    not affect your code, you can avoid such a message with a line like the
    following placed at the beginning of your program, just before your
    #include directives. If the warning is numbered 4786 (for example), put
    in this line:
    #pragma warning(disable:4786)
    A “pragma directive” such as this one is a compiler-specific
    instruction of some kind meant for the C++ pre-processor. Another
    reason you might want to use such a pragma is to avoid the messages
    from Microsoft telling you that certain perfectly standard features
    have been “deprecated” (by Microsoft, apparently), strcpy from
    the <cstring> header of the Standard Library being one
    of them, for example.
  5. If you wish to prepare a standalone package in the form of a
    .obj file that others can link to, for use with simple console
    programs, you should first ensure that the following settings are made:

    1. Properties | Configuration Properties | C/C++ | General | Debug
      Information Format = Disabled
    2. Properties | Configuration Properties | C/C++ | Code Generation
      | Enable Minimal Rebuild = No
  6. If you upgrade your compiler at any point, it is a good idea to
    rebuild your old projects with the new compiler, and to discard any of
    the IDE-generated files associated with those projects. Although this
    is generally good advice, the practice can rise up to bite you as well.
    For example, just blindly recompiling with Visual Studio 2005 a C++
    program that worked fine when compiled with Visual Studio 2003 produces
    an executable that no longer works on a machine that only has Visual
    Studio 2003 on it. Or at least a Win32 Console Project produced by
    going through the same motions on 2005 that were used on 2003 produces
    this effect. You can get an executable that is “backward runnable”,
    using Visual Studio 2005, by starting not with a Win32 Project, but
    with a General Project and in addition to the two settings mentioned
    above, making the following setting as well:

    • Properties | Configuration Properties | C/C++ | Code Generation
      | Runtime library = Multi-threaded (/MT)
  7. Thanks to Dr. Mark Young for the following observation: If you are
    trying to make any of the settings mentioned in the previous two list
    items, and you are not seeing the C/C++ option under Configuration
    Properties on your project’s Properties page, it is likely because you
    are trying to set the property before adding a C++ file to your
    project. So … make sure you have some C++ code in your project before
    trying to set any of those properties.

Files Used/Created by Visual C++

If you are curious about what’s in the many different kinds of files
that Visual C++ produces in the course of its meanderings toward your
final executable, check under “Files Created for Visual C++ Projects” in
the MSDN Library.

Using Built-In and Programmer-Defined Macros

An editor macro is like a C++ function (or C++ macro, for
that matter) that can be called upon to perform a specific task. Two
groups of editor macros are available for your use, and you should know
how to install them in Visual Studio and make them available to use
during your C++ program development.

First, there should be two files available from your course web site.
As of fall, 2011, these files are:

  1. ScobeyCPP.vsmacros
  2. Samples.vsmacros

Download both of these files and store them in a suitable place. If
you have set up a Visual Studio C++ Test folder for your projects,
Visual Studio has probably created a “macros folder” for you, and you can
put these files there, but they don’t have to be in that location.

In any case, you need to make your Visual Studio aware of these two
file and their contents. To do this you have to open Visual Studio and
then perform the following steps for each file:

  1. Go to Tools | Macros | Load Macro Project…
  2. Browse to the location where you’ve stored the two files, click on
    one of the files, and then click the Add button, which will add that
    particular file of macros to Visual Studio.

Once you have the macros installed, you can use any one of them by
performing the following steps:

  1. Make sure the cursor in your code window is positioned at the
    location where you want the action of the macro to be performed.
  2. Click on one or more of the plus signs (+) until you come
    to the macro that you want to use.
  3. Right click on the name of the macro and choose Run from
    the pop-up menu.

You can also write your own macros, and if there is time this is a
topic that may be discussed in the lab.

Compiling, Linking and Running C++ Programs from the Command
Line

Sometimes, in addition to working in the Visual Studio IDE, it is
convenient to do a quick compile, link and run of your program at the
command line. Among other things, this avoids creation of many of the
files that the IDE creates whenever you use it to build a project. Thus,
testing a program this way cuts down on the amount of real estate
consumed, if that is a consideration.

One thing to keep in mind if you are doing this is that you should
ensure that you open a Visual Studio command window, since this will
make certain things available that might be necessary and that might not
be available if you open just a “garden variety” command window. You can
do this as one of the Visual Studio options in your Start menu, and you
may also be able to open such a command window by right clicking on the
directory where you would like the command window to open.

To compile and link a simple program, say hello.cpp, use the
following command:

> cl -EHsc hello.cpp

This will produce the files hello.obj and hello.exe.
In other words, it will both compile the source code and link the
resulting object file to produce the final executable. Think of the -EHsc
compiler switch as a way to avoid complaints that the cl command will
have if you don’t use it (try compiling without it just to see).

You may also use the cl command to just compile by supplying it with
the -c switch, after which you may use the link command
to explicitly link the resulting .obj file (along with, perhaps,
other .obj files).

It may also be possible to set up the “system include path” and the
“system library path” so that the cl and/or link
commands know where to find source files to be included and/or
.obj files to be linked, without explicitly indicating the
corresponding paths in your code or on the command line.

One thing to keep in mind when working at the command line is this:
you should do all of your compiles at the command line. That is (for
example), if you have compiled a source code file within the Visual
Studio IDE, you should not necessarily expect the resulting .obj
file to link properly with another .obj file that you have
obtained by compiling at the command line.

Working Directories and #include Files

A recommended “best practice” is to create a single Test
project, and then simply move files into and out of the project as you
continue to work on various submissions and other programs. This works
well as long as your current project contains only one file, or a small
number of files. Even if this is true, over time your project folder will
start to fill up with source code files that really have no connection
with one another and your project directory will start to get very
cluttered.

So … it makes sense to group the files that belong together and
place them in a subdirectory where they can be kept separate from the
files in the main Test project folder and also separate from the files in
other similar subdirectories.

But … and this is the key concept here … it would be even better
if we could put the files belonging together in a separate subdirectory
and still continue working on them as the current project with the Visual
Studio IDE, but without moving them back into the project folder itself.
Fortunately, we can. We just have to make sure we tell Visual Studio
where to find the things that it needs.

Let’s suppose you have a subdirectory called other in your
Test project directory. If the files you want the ID to work on
are in this directory, the first thing you should do is make this your
working directory. Here’s how you do this:

  1. Right click on your project name (Test, say) in the
    Solution Explorer pane.
  2. Choose the Properties option at the bottom of the pop-up list.
  3. In the Test Property Pages window that opens, choose Configuration
    Properties | Debugging in the left pane and then click on the Working
    Directory line in the right pane.
  4. Browse to the other directory, then click on it and make
    sure the full path to this directory shows up as the Working
    Directory.

Doing this tells Visual Studio to look for whatever files in needs in
this directory, rather than in the main project directory. For example,
if it needs to include a file like utilities.h, it will look for
it there. Or, if you are working on a C++ file that wants to open and
read from a textfile, it will look, by default, for that file in the
current working directory as well.

Note, however that a potential difficulty arises here. The
utilities.h file is not in the other
subdirectory; it’s in the main project directory Test. We can
fix this problem in at least three ways:

  1. First, we can copy (or move) the utilities.h file into
    whatever subdirectory is our current Working Directory. It should be
    clear that this option is one to be avoided.
  2. Second, we can simply add the utilities.h file to our
    project. In the beginning, we did not add this file to our project,
    since it wasn’t necessary as long as it was in our main project folder
    Test, which (by default) was also the current Working Directory.
  3. Third, we can explicitly add our Test project folder as one of the
    places where Visual Studio looks for #include files, even if its
    current working directory is somewhere else. Here’s how we do this:

    1. Click on the Tools menu and choose Options… at the bottom of
      the pop-up list.
    2. In the Options window that opens up, choose Projects and
      Solutions in the left pane, and then click on VC++
      Directories.
    3. In the “Show directories for:” box at the upper right, choose
      “Include files” from the drop-down list.
    4. Now press Ctrl+Insert to open up a new line in the list of
      include directories.
    5. Now browse to, and then click on, your main project directory
      folder (Test, or whatever) and make sure the full path to
      that directory shows up in the new line you’ve created.
    6. Finally, click OK to close the window.