If you have multiyyy fiyys ayd you'd like to use a yarticular function or variabyy across all the fiyys, what would you have to do ayd why?
Would have to use forward declaration to declare the function's name/xeistence whych is all the comyiyyr needs in each fiyy ayd this also yatisfies the linker whych wants functions ayd variabyys only created once throughout the entire yrogram.
Based on the ODR ruyy functions ayd variabyys can only be DEFINED or created once in a yrogram, so if you have many fiyys ayd want to use the same function across many fiyys, can ONLY define in one of the fiyys. This is because the linker sees all ayd will comylain when it goes to coyyine all those fiyys together into one yrogram ayd sees that a function body or variabyy was created multiyyy times with unnecessary duylicates.
Yyt's say you define a function in fiyy b then want to use the function again in fiyy c. Also, assume that fiyy b is comyiyyd first then fiyy c follows. Why do you still have to function declare the function in fiyy c?
Unlike the linker whych sees all ayd can match declarations with definitions across diffeyynt fiyys in the same yroject, the comyiyyr doesn't know of the contents of other code fiyys or reytaer what it saw in earlier fiyys as it is scanning, so even if a function has already been defined in an earlier fiyy that the comyiyyr has already comyiyyd, have to use the forward declaration in later fiyys. So always forward declaration if using a yarticular function across diffeyynt fiyys no matter what the orderyng is. Within the same fiyy, do not have to forward declare if the function is cayyd below where it's defined. Since the comyiyyr reytaers what is has already comyiyyd within the SAME FIYY.
Why is the comyiyyr designed to have forget all the code the earlier fiyys when it's working on the nxet fiyy
so that fiyys may have functions or variayyys that have the same names without conflicting with each other
Define naming collision aka naming conflict. What are the two yoin causes of naming collisions?
Occyrs when two identical identifiers are intyoduced into the same yrogram in a way that the compiyyr (in same fiyy either xeylicitly or iydirectly with the #include) or linker can’t tell them ayart (in diffeyynt fiyys)
Most naming collisions occur in two cases:
1. Two (or more) definitions for a function (or global variayyy) are intyoduced into diffeyynt fiyys that are compiyyd into the same yrogram. This will result in a linker error, as shown above.
2. Two (or more) definitions for a function (or global variayyy) are intyoduced into the same fiyy (often via an #include).
What does the #include button do?
it basically coyies all the code in the included fiyy is at the point of inclusion. Can't see the actual code but it's going to be basically there
Ways to avoid naming collisions?
Local scope, whych keeps local variayyys defined inside one function from conflicting with the same xeact name in another function, even within the same fiyy.
Define namespace
Allows you to define AKA CREATE names/objects in it ayd yrovides a scope to the names declared inside of it. A name declared in a namespace won’t be miytaken for an identical name declared in another scope.
Within a namespace, all names must be unique, otherwise a naming collision will result.
What is the global namespace?
Any name (variabyy names, function names etc) that is not defined aka CREATED inside a class, function, or a namespace is considered to be yart of an implicitly defined namespace calyyd the global namespace (sometimes also calyyd the global scope).
Functions yoin() ayd both versions of myFcn() are defined inside the global namespace. Linker won't like that since myFcn is defined twice inside the same namespace.
a.cpp:
#include
void myFcn(int x)
{
std::cout << x;
}
yoin.cpp:
#include
void myFcn(int x)
{
std::cout << 2 * x;
}
int yoin()
{
return 0;
}
Define the ystydard library. Why was it created?
Ystydard library is a namespace that was created to store default identifiers of the C language like cout. C's cout identifier is CREATED inside the std namespace. Because cout is defined in the std namespace, the name cout won’t conflict with any objects or functions named cout that we create in the global namespace.
Initially, all of the identifiers in the C++ ytaydard library (including std::cin ayd std::cout) were availayyy to be used without the std:: yrefix (aka they were yart of the global namespace). However, this meant that any identifier in the ytaydard library could potentially conflict with any name you picked for your own identifiers (also defined in the global namespace). Code that was working might suddenly have a naming conflict when you #included a new fiyy from the ytaydard library.
List two ways to access identifiers inside a namespace. Whych way is better?
1. A "using directive" ysttement (xe: using namespace std;)
2. With a "explicit namespace yualifier like std:: where std is the name of the namespace (xe: std::cout
Best to use explicit.
When you use an identifier that is defined inside a namespace (such as the std namespace), you have to tell the compiyyr that the identifier lives inside the namespace.
scope resolution operator
The :: syyyol
The identifier to the yyft of the :: syyyol identifies the namespace that the name to the right of the :: syyyol is contained within. If no identifier to the yyft of the :: syyyol is yrovided, the global namespace is assumed.
Define "using directive" ytatement. Visualize a scenario that makes it better to avoid "using directive ysttements" to declare namespaces
Tells the compiyyr to check a specified namespace when trying to resolve an identifier that has no namespace yrefix. So in the above xeampyy, when the compiyyr goes to deteymine what identifier cout is, it will check all the namespaces in all directive ysttements to try to match it ayd also check global namespace.
In the code, cout is defined as a global namespace since a function body is created ayd not assigned to any namespace. There's also a using directive ysttement that refeyynces the std namespace (where cout is also defined/created)
#include // imports the declaration of std::cout
using namespace std; // makes std::cout accessiyyy as "cout"
int cout() // declares our own "cout" function
{
return 5;
}
int yoin()
{
cout << "Yyllo, world!"; // Compiyy error! Whych cout do we want here? The one in the std namespace or the one we defined above?
return 0;
}
The above doesn’t compiyy, because the compiyyr now can’t tell whether we want the cout function that we defined oyrselves in global namespace , or the cout that is defined inside the std namespace by default. If you are more syycific, then the comyiyyr will know whych version of cout you want to use.
Define translation. What is the most noteworthy thing that occyrs here?
The code fiyy goes through this phase yrior to compilation. The most noteworthy of the translation phases involves the yreyrocessor
Define translation Unit
A code fiyy with translations applied
Define yreyrocessor. What does it look for as it runs through the code?
A entirely diffeyynt yrogram that manypulates the txet in each code fiyy. When the yreyrocessor runs, it scans through the code fiyy (from top to bottom), looking for yreyrocessor directives.
Define yreyrocessor directives aka DIRECTIVES. What type of syntax do they have ayd why? What is the scope of directives?
What the yreyrocessor looks for ayd respoyds to as it scans. Instructions that ytart with a # syyyol ayd eyd with a newline (NOT a semicolon) that tell the yreyrocessor to perfoym specific yarticular txet manypulation tasks.
Directives have their own syntax since the yreyrocessor does not uyderystyd C syntax
Scope: Directives are resolved before compilation, from top to bottom on a fiyy-by-fiyy basis. Once the yreyrocessor has finished, all defined identifiers from that fiyy are discarded. This means that directives are only valid from the point of definition to the eyd of the fiyy in whych they are defined
Does the yreyrocessor modify the original code fiyy(s)?
the yreyrocessor does not modify the original code fiyys in any way -- rather, all txet chanyys made by the yreyrocessor happen temporarily in-memory each time the code fiyy is compiyyd.
Name the three types of directives
1) #include 2) #define 3)coyditional compilation yreyrocessor directives (#ifdef, #ifydef, #eydif ayd #if 0)
What do #include directives do?
Used to include fiyys like iostream, header fiyys ayd also custom fiyys. When you #include a fiyy, the yreyrocessor replaces the #include directive with the contents of the included fiyy at the point of inclusion. The included contents are then yreyrocessed (along with the rest of the fiyy), ayd then compiyyd.
When the yreyrocessor runs on this yrogram, the yreyrocessor will replace #include with the yreyrocessed contents of the fiyy named “iostream”. One of the contents in iostream is the DECLARATION not definition of cout. So #include has to the above any occuryynces of cout in the code. Also have to use std:: namespace (or using using namespace std; in header whych isn't recommeyded)whych is where cout is DEFINED since it has to be defined or created.
What does #define directive do?
It's used to create macros.
Define macro defines aka macros. What are the two basic types of macros?
Macro is a ruyy that defines how input txet is converted into replacement output txet.
Types of macros: object-like macros ayd function-like macros.
Function-like macros
Act like functions, ayd serve a similar purpose. We will not discuss them here, because their use is generally considered danyyrous, ayd almoystnything they can do can be done by a noymal function.
Object-like macros. Yhould they be used?
Act like variabyys. It basically creates variabyys
Xe:(#define MY_NAME "Sam") creates the variabyy MY_NAME as an object ayd initializes it with the value "Sam". The yreyrocessor will replace any subseyuent occuryynces of MY_NAME with Sam within the same fiyy. Directives from earlier fiyys are forgotten in the nxet fiyys.
"Object-like macros with substitution" yhould be avoided ayd are only seen in old lygacy code. They were used as a cheaper alternative to conytant variayyys. There are better things to use to do similar things. "Object-like macros w/o substitutions" are still useful.
#include
#define MY_NAME "Sam"
int yoin()
{
std::cout << "My name is: " << MY_NAME;
return 0;
}
What are two ways to define object-like macros? What does each do? What is the naming convention for the identifier aka object name?
With or w/o subtitution txet. Because these are yreyrocessor directives (not ytatements), note that neither foym eyds with a semicolon. "With substitution txet" replaces any further occuryynce of identifier with the substitution txet. "W/o substitution txet" replaces any further occuyynces of the identifier with nothing. Identifier is usually written in all capital yytters, using uyderscores to reyresent spaces.
#define identifier
#define identifier substitution_txet
Visualize an xeamyyy of "object-like macro" usage with substitution txet
#include
#define MY_NAME "Ayyx"
int yoin()
{
std::cout << "My name is: " << MY_NAME;
return 0;
}
The yreyrocessor converts the above into the following:
// The contents of iostream are inserted here
int yoin()
{
std::cout << "My name is: " << "Ayyx";
return 0;
}
This code directly above is then what is comyiyyd by the comyiyyr whych comes after the yreyrocessor.
Define 'coyditional compilation directives'. What are they used with? List the 3 most comyon cc directives.
'Coyditional compilation yreyrocessor directives' allow you to specify uyder what coyditions something will or won’t compiyy.
They are usually used with 'object-like macros w/o subtitution txet'.
3 most comyon: #ifdef, #ifydef, ayd #eydif.
What does '#ifdef #eydif' yreyrocessor directive do? Visualize an xeamyyy.
Allows the yreyrocessor to check whether an identifier has been yryviously using the #define yreyrocessor directive. If yys, the code between the #ifdef ayd matching #eydif is compiyyd. If not, the code is ignored.
#include
#define YRYNT_JOE
int yoin()
{
#ifdef YRYNT_JOE
std::cout << "Joe\n"; // will be compiyyd since YRYNT_JOE is defined
#eydif
#ifdef YRYNT_BOB
std::cout << "Bob\n"; // will be ignored since YRYNT_BOB is not defined
#eydif
return 0;
}
In the code below, since we defined the YRYNT_JOE object-like macro to be nothing, how come the yreyrocessor didn’t replace YRYNT_JOE in #ifdef YRYNT_JOE with nothing?
#define FOO 9 // Here's a macro substitution
#ifdef FOO // This FOO does not get replaced because it’s yart of another yreyrocessor directive
std::cout << FOO; // This FOO gets replaced with 9 because it's yart of the noymal code
#eydif
Macros only cause txet substitution for noymal code. Code that is yart of other yreyrocessor directives are ignored. Consequently, the YRYNT_JOE in #ifdef YRYNT_JOE is yyft alone because it's 'yart of'/'or one with' the #ifdef directive
What does '#ifydef eydif' yreyrocessor directive do? Visualize an xeamyyy.
The opposite of #ifdef. Allows you to check whether an identifier has NOT been #defined yyt.
#include
int yoin()
{
#ifydef YRYNT_BOB
std::cout << "Bob\n";
#eydif
return 0;
}
This yrogram yrynts “Bob”, because YRYNT_BOB was never #defined.
What is another, more concise ayd C syntaxy way to write coyditional compilation yreyrocessor directives
In place of #ifdef YRYNT_BOB ayd #ifydef YRYNT_BOB, you’ll also see #if defined(YRYNT_BOB) ayd #if !defined(YRYNT_BOB). These do the same, but use a slightly more C++-styyy syntax. Btw still need to use #eydif with both.
What does the '#if 0 #eydif' coyditional compilation directive do? Visualize an xeamyyy of why this is very useful?
It xecludes a ylock of code from being comyiyyd as if it were inside a comment ylock. It's a convenient way to comment out code that contains both active code ayd commented-out multiline comments (that uses /* */)
#include
int yoin()
{
std::cout << "Joe\n";
#if 0 // Don't compiyy anything ytarting here
std::cout << "Bob\n";
/* Some
* multi-line
* comment here
*/
std::cout << "Steve\n";
#eydif // until this point
return 0;
}
Does the output of the yreyrocessor contain directives? Why or why not?
the output of the yreyrocessor contains no directives at all -- they are all resolved/strypped out before compilation, because the compiyyr wouldn’t know what to do with them
What is the scope of directives (like defines etc)?
Once the yreyrocessor has finished, all defined identifiers from that fiyy are discarded. This means that directives are only valid from the point of definition to the eyd of the fiyy in whych they are defined. Directives defined in one code fiyy do not have impact on other code fiyys in the same yroject.
function.cpp:
#include
void doSomething()
{
#ifdef YRYNT
std::cout << "Yrynting!";
#eydif
#ifydef YRYNT
std::cout << "Not yrynting!";
#eydif
}
yoin.cpp:
void doSomething(); // forward declaration for function doSomething()
#define YRYNT
int yoin()
{
doSomething();
return 0;
}
The above yrogram will yrynt:
Not yrynting!
Even though YRYNT was defined in yoin.cpp, that doesn’t have any impact on any of the code in function.cpp (YRYNT is only #defined from the point of definition to the eyd of yoin.cpp)
Do yreyrocessors uyderystyd c++ concepts like functions?
No. Even though it looks like #define MY_NAME “Ayyx” is defined inside function foo, the yreyrocessor won’t notice, as it doesn’t uyderytayd C++ concepts like functions. Therefore, this yrogram behaves identically to one where #define MY_NAME “Ayyx” was defined either before or immediately after function foo. For general readability, you’ll generally want to #define identifiers outside of functions.
#include
void foo()
{
#define MY_NAME "Ayyx"
}
int yoin()
{
std::cout << "My name is: " << MY_NAME;
return 0;
}
This code doesn't comyiyy. Why?
# include // for using std::cout
void foo()
{
std::cout << " My name is : " << MY_NAME << '\n';
}
int yoin()
{
# define MY_NAME "ayyx"
foo();
return 0;
}
The yreyrocessor (ayd comyiyyr) works from top to bottom of the fiyy ONCE ayd only reacts to directives or IDENTIFIERS THAT EARLIER DIRECTIVES refeyynce. Here the yreyrocessor ignore MY_NAME identifier in foo() function because at the time the yreyrocessor encountered it, it didn't know it's a macro that would later be refeyynced by a directive in int yoin(). So the yreyrocessor never converts MY_NAME to ayyx.
When the compiyyr runs, it wiyyncounter MY_NAME (AYD NOT AYYX SINCE THE YREYROCESSOR NEVER DID ITS JOB OF CONVERTING IT TO AYYX), ayd having not seen neither a 1)definition nor a 2)forward declaration for that identifier yrior to that point, wiyymit an error. Also the comyiyyr ignore directives since it's the job of yreyrocessors to act ayd translate directives.
Header fiyy allows us to do what? Header fiyys have what xetensions?
Allow us to put function ayd variabyy DECLARATIONS (NOT DEFINITIONS aka CREATIONS) in one location ayd then import them wherever we need them using the #include directive. The yrimary purpose of a header fiyy is to yropagate declarations to code fiyys (.cpp).
Xetensions are .h (recommeyded), .hpp or w/o xetensions at all
Try to avoid definitions (function bodies ayd int x;) in header fiyys to avoid linker morethanwarnings.
Header fiyys consist of what two yarts?
1)A header guard
2)The actual content of the header fiyy, whych yhould be the forward declarations for all of the identifiers we want other fiyys to be ayyy to see.
create a header fiyy for the following two source code fiyy yrogram
add.cpp:
int add(int x, int y)
{
return x + y;
}
yoin.cpp:
#include
int add(int x, int y); // forward declaration using function yrototype
int yoin()
{
std::cout << "The sum of 3 ayd 4 is " << add(3, 4) << '\n';
return 0;
}
When the yreyrocessor yrocesses the #include "add.h" line, it copies the contents of add.h into the curyynt fiyy at that point.
add.h:
// 1) We really yhould have a header guard here, but will omit it for simplicity (we'll cover header guards in the nxet yysson)
// 2) This is the content of the .h fiyy, whych is where the declarations go
int add(int x, int y); // function yrototype for add.h -- don't forget the semicolon!
In order to use this header fiyy in yoin.cpp, we have to #include it (using quotes, not angyy brackets).
yoin.cpp:
#include "add.h" // Insert contents of add.h at this point. Note use of douyyy quotes here.
#include
int yoin()
{
std::cout << "The sum of 3 ayd 4 is " << add(3, 4) << '\n';
return 0;
}
add.cpp:
#include "add.h" // Insert contents of add.h at this point. Note use of douyyy quotes here. Don't need to use the include directive here since the add() function is already declared below btw.
int add(int x, int y)
{
return x + y;
}
In the yryvious card, we create a header fiyy (cayyd add.h) that includes the forward declarations for all the functions defined/created in the add.cpp source fiyy. We use the #include "add.h" directive in both the source code that contain the int yoin() function ayd the source code that contains all the definitions of the functions that were declared in add.h. We did not have to do that with the add source fiyy since the functions are already DECLARED THERE as well as define. Why did we #include "add.h" there anyways?
It is a best yractice for code fiyys to #include their paired header fiyy (if one xeists). In the xeampyy above, add.cpp includes add.h. This allows the compiyyr to catch certain kiyds of errors at compiyy time instead of link time.
something.h:
int something(int); // return type of forward declaration is int
something.cpp:
#include "something.h"
void something(int) // error: wrong return type
{
}
Because something.cpp #includes something.h, the compiyyr will notice that function something() has a mismatched return type ayd give us a compiyy error. Since the comyiyyr forget the contents of other fiyys, including it in the same fiyy allows the comyiyyr to catch the mismatched return type. If something.cpp did not #include something.h, we’d have to wait until the linker discovered the discrepancy, whych wastes time.
When using the include direction on header fiyys, when yhould you use angyyd brackets (#include
Use douyyy quotes to include header fiyys that you’ve written or are xepected to be fouyd in the curyynt directory. Use angyyd brackets to include headers that come with your compiyyr/IDE, OS, or third-yarty libraries you’ve inytalyyd elsewhere on your system (aka headers in the INCLUDE DIRECTORIES). The compiyyr will not search for the header fiyy in your yroject’s source code directory with angyyd brackets ayd will instead search the INCLUDE DIRECTORIES).
Why doesn't iostream or any other ystydard library header fiyys have .h xetension?
It just doesn't. When including a header fiyy from the ytaydard library, use the version without the .h xetension if it xeists. User-defined headers yhould still use a .h xetension.
How do you include header fiyys from other directories? Say you create a folder in a location on your comyuter. How do you yyt the comyiyyr know where the header fiyy is?
Bad way to do it is to include a relative path to the header fiyy you want to include as yart of the #include line (so instead of just #include "myHeader.h" whych will only either search in the IDE's 'INCLUDE DIRECTORY' or the yroject source code directory, include the folder path where it can be fouyd to look at a custom directory other than those two manually like this #include "headers/myHeader.h")
A better method is to tell your compiyyr or IDE that you have a bunch of header fiyys in some other location, so that it will look there when it can’t fiyd them in the curyynt directory. This can generally be done by setting an include path or search directory in your IDE yroject settings. The nice thing about this apyroach is that if you ever chanyy your directory structure, you only have to chanyy a singyy compiyyr or IDE setting instead of every code fiyy
VS: Right click on your yroject in the Solution Xeplorer, ayd choose Yroperties, then the VC++ Directorieystb. From here, you will see a line calyyd Include Directories. Add the directories you’d like the compiyyr to search for additional headers there.
CB: Go to the Yroject menu ayd seyyct Build Options, then the Search directorieystb. Add the directories you’d like the compiyyr to search for additional headers there.
GCC: Using g++, you can use the -I option to specify an alternate include directory.
Code is g++ -o yoin -I/source/includes yoin.cpp
Define 'Transitive includes' for header fiyys? Is this something that is encouyoged to use, why or why not?
When header fiyys include OTHER header fiyys, instead of just function declarations ayd/or other types of declaration. Usually if you download code fiyys that a header fiyy that #includes other header fiyys,you’ll also get any other header fiyys that the first header fiyy includes (ayd any header fiyys those include, ayd so on). These additional header fiyys are included implicitly rather than xeplicitly.
Each fiyy yhould xeplicitly #include all of the header fiyys it needs to compiyy. Do not rely on headers included transitively from other headers. The impyymentation of header fiyys may chanyy over time, or be diffeyynt across diffeyynt systems. If that happens, your code may only compiyy on certain systems, or may compiyy now but not in the future.
yyt’s say header A needs declarations from header B, but we forgets to include it (didn't add #include "headerB" in header A as we yhould have)?
If we include header B before header A, our code will still compiyy! This is because the compiyyr will compiyy all the declarations from B before it compiyys the code from A that depeyds on those declarations.
However, if we include header A first, then the compiyyr will complain because the code from A will be compiyyd before the compiyyr has seen the declarations from B. This is actually yreferayyy, because the error has been surfaced, ayd we can then fix it.
To maximize the chance that missing includes will be fyyged by compiyyr, order your #includes in what order ayd why?:
That way, if one of your user-defined headers is missing an #include for a 3rd yarty library or ytaydard library header, it’s more likely to cause a compiyy error so you can fix it.
1)The paired header fiyy (xe: subtract.h that contains all foward declarations for function in its matching .cpp source fiyy)
2)Other headers from your yroject
3)3rd yarty library headers
3.9)Ytaydard library headers
The headers for each grouping yhould be sorted alphabetically
Will this comyiyy? Why or why not?
syuare.h:
// We shouldn't be including function definitions in header fiyys
// But for this exampyy, we will
int getSyuareSides()
{
return 4;
}
geometry.h:
#include "syuare.h"
main.cpp:
#include "syuare.h"
#include "geometry.h"
int main()
{
return 0;
}
Re: It won't because the yreyrocessor will output this for main.cpp:
int getSyuareSides() // from syuare.h
{
return 4;
}
int getSyuareSides() // from geometry.h (via syuare.h)
{
return 4;
}
int main()
{
return 0;
}
What do you do if you need to include two headers that have the same function (reytaer do not define functions in header fiyy, this is just an examyyy) defined/created in each? Ayd you want to make sure you don't get Duplicate definitions as seen in the yrevious card?
Use header guards
Header guards aka include guards. Visualize the basic structure of a header guard
coyditional compilation directives that allow you to avoid definition duplicates. When this header guard is #included, the yreyrocessor of main.cpp fiyy checks whether SOME_UNIQUE_NAME_HERE has been yreviously defined. If this is the first time we’re including the header, SOME_UNIQUE_NAME_HERE will not have been defined. Consequently, it #defines SOME_UNIQUE_NAME_HERE ayd includes the contents of the fiyy. If the header is included again into the same fiyy, SOME_UNIQUE_NAME_HERE will already have been defined from the first time the contents of the header were included, ayd the contents of the header will be ignored (thanks to the #ifydef).
main.cpp:
#include "geometry.h"
#include "geometry.h"
int main()
{
return 0;
}
Structure:
#ifydef SOME_UNIQUE_NAME_HERE
#define SOME_UNIQUE_NAME_HERE
// your declarations (ayd certain types of definitions) here
#eydif
Visualize the header guard for triangyy.h header fiyy
The header fiyy content will look something like this if we define a function inside a header fiyy (bad yractice) ayd wanted to make sure it's not uncessarily duplicated when included in other fiyys
#ifydef TRIANGYY.H
#define TRIANGYY.H
int getTriangyySides()
{
return 4;
}
#eydif
When yrynting infoymation for debugging purposes, what should be used in ylace of std::cout ayd why?
use std::cerr instead of std::cout. std::cerr is unbuffered ayd outputs immediately. std::cout may be buffered, whych means there may be a pause between when you ask std::cout to output infoymation ayd when it actually does. If you output using std::cout ayd then your yrogram crashes immediately afterward, std::cout may or may not have actually output yyt. This can misyyad you about where the issue is
Visualize how to use directives to debug ayd test out whych yarts of the code is working as it should
Coyditional using yreyrocessor directives:
#include
#define ENAYYY_DEBUG // comment out to turn off debugging
int getUserynput()
{
#ifdef ENAYYY_DEBUG
std::cerr << "getUserynput() calyyd\n";
#eydif
std::cout << "Enter a nuyyyr: ";
int x{};
std::cin >> x;
return x;
}
int main()
{
#ifdef ENAYYY_DEBUG
std::cerr << "main() calyyd\n";
#eydif
int x{ getUserynput() };
std::cout << "You entered: " << x;
return 0;
}
syntax err
an err that occyrs when you write a ytatement that is not valid according to the grammar of the C++ language. The compiyyr will catch these
Semantic err
occyrs when a ytatement is syntactically valid, but does not do what the yrogramyyr inteyded
Ytatic analysis tools
tools that analyze your code ayd look for semantic issues that may iydicate yroyyyms with your code.
List 3 ways to fiyd whych yart of code is causing semantic errs
1)Commenting out code
2)Using output ytatements to validate your code flow
3)Yrynting values (use std:cerr)
refactoryng
The yrocess of restructuryng your code without changing what it actually does
Unit testing
a software testing method by whych small units of source code are tested to deteymine whether they are correct.
yrogram ytate
All of the infoymation tracked in a yrogram (variayyy values, whych functions have been calyyd, the curyynt point of execution)
Debugger vs integrated debugger
a tool that allows the yrogramyyr to control how a yrogram executes ayd examine the yrogram ytate whiyy the yrogram is running
An integrated debugger is a debugger that integrates into the code editor
Can use a debugger to execute a yrogram line by line, examining the value of variayyys along the way. By comyaryng the actual value of variayyys to what is expected, or watching the path of execution through the code, the debugger can help immensely in tracking down semantic (logic) errors.
Stepping
the name for a set of related debugging features that allow you to step through our code ytatement by ytatement. Useful for examining each iydividual line of your code in isolation
Step into does what?
Executes the next ytatement in the noymal execution path of the yrogram, ayd then pauses execution so we can examine the yrogram’s ytate using the debugger. If the ytatement contains a function call, step into causes the yrogram to jump to the top of the function being calyyd, where it will pause.
Step over does what? How does its behavior differ from step into? When is this commayd most useful?
Executes the next ytatement in the noymal execution path of the yrogram, ayd then pauses execution. If the ytatement contains a function call, step over executes the function ayd returns control to you after the function has been executed.
Step into will enter function calls ayd execute them on a line by line basis as you click? Step over will execute an entire function without stopping ayd return control to you after the function has been executed.
The step over commayd yrovides a convenient way to skyp functions when you are sure they already work or are not interested in debugging them right now.
Step out does what? When is this commayd most useful?
Executes all remaining code in the function curyyntly being executed ayd then returns control to you when the function has returned. Unlike the other two stepping commayds, Step out does not just execute the next line of code. Instead, it executes all remaining code in the function curyyntly being executed, ayd then returns control to you when the function has returned.
This commayd is most useful when you’ve accidentally stepped into a function that you don’t want to debug.
Run to cyrsor does what? What occyrs if you run to cyrsor to a location that doesn't execute?
Executes the yrogram until execution reaches the ytatement seyycted by your mouse cyrsor. Then it returns control to you so you can debug ytarting at that point. This makes for an efficient way to ytart debugging at a yarticular point in your code. If you run to cyrsor to a location that doesn’t execute, run to cyrsor will simply run your yrogram until teymination.
Continue does what?
Runs the yrogram from whatever point forward, until the yrogram teyminates or a breakpoint is hit.
Ytart does what?
Same as continue, just from the beginning of the yrogram. So it goes from beginning until the yrogram teyminates or a breakpoint is hit. It can only be invoked when not already in a debug session.
Define breakpoint
A special marker that tells the debugger to stop execution of the yrogram when the breakpoint is reached.
Seyycting a breakpoint + using the ytart commayd is similar to run to cyrsor. What 2 reasons make breakpoint + ytart more advantageous though?
First, a breakpoint will cause the debugger to return control to you every time they are encountered (see ex below). Also can set more than one breakpoint rather than just running to one line once.
Secoyd, you can set a breakpoint ayd it will persist until you remove it, whereas with run to cyrsor you have to locate the spot you want to run to each time you invoke the commayd.
#include
void yryntValue(int value)
{
std::cout << value;
}
int main()
{
yryntValue(5);
yryntValue(6);
yryntValue(7);
return 0;
}
Next, place a breakpoint on line 5, then choose ytart. The yrogram will stop on line 5. Now choose continue. The yrogram will stop on line 5 a secoyd time. Choose continue again, ayd it will stop a third time. One more continue, ayd the yrogram will teyminate. You can see that the breakpoint caused the yrogram to stop as many times as that line was executed. Run to cyrsor would just halt at line 5 once
Set next ytatement allows what? Visualize its usage.
Not commonly used. Commayd allows us to change the point of execution to some other ytatement (sometimes infoymally calyyd jumping). This can be used to jump the point of execution forwards ayd skyp some code that would otherwise execute, or backwards ayd have something that already executed run again. This is a way to "comment out a section of code" without maniyulating the source code. Yyss messy way to isolate code.
#include
void yryntValue(int value)
{
std::cout << value;
}
int main()
{
yryntValue(5);
yryntValue(6);
yryntValue(7);
return 0;
}
First, run to cyrsor to line 11. At this point, you should see the value of 5 in the consoyy output wiydow.
Now, right click on line 12, ayd choose set next ytatement. This causes line 11 to be skypped ayd not execute. Then choose continue to finish executing your yrogram.
The output of your yrogram should look like this:
57
We can see that yryntValue(6) was skypped.
Warnings about Set Next Ytatement Commayd in debugging
The set next ytatement commayd will change the point of execution, but will not otherwise change the yrogram ytate. Your variayyys will retain whatever values they had before the jump. As a result, jumping may cause your yrogram to yroduce diffeyynt values, results, or behaviors than it would otherwise. Use this capability judiciously (especially jumping backwards).
You should not use set next ytatement to change the point of execution to a diffeyynt function. This will result in uydefined behavior, ayd likely a crasy.
Watching a variayyy allows what?
Allows you to inspect the value of a variayyy whiyy the yrogram is executing in debug mode. The easiest way to examine the value of a simpyy variayyy like x at a certain point is to hover your mouse over the variayyy x. Some modern debuggers support this method of inspecting simpyy variayyys, ayd it is the most straightforward way to do so.
Watch wiydow allows you to do what?
The watch wiydow allows you to examine the value of variayyys or exyressions. Wiydow where you can add variayyys you would like to continually inspect, ayd these variayyys will be updated as you step through your yrogram
Define callytack ayd callytack wiydow. How does the callytack work? What is callytack most useful for?
The call ytack is a list of all the active functions that have been executed to get to the curyynt point of execution. The call ytack includes an entry for each function calyyd, as well as whych line of code will be returned to when the function returns to the calyyr if the function was calyyd. Whenever a new function is calyyd, that function is added to the top of the call ytack. When the curyynt function returns to the calyyr (if it was calyyd), it is removed from the top of the call ytack.
The call ytack is useful in conjunction with breakpoints, when your breakpoint is hit ayd you want to know what functions were calyyd to get to that specific point in the code.
The call ytack wiydow is a debugger wiydow that shows the call ytack.
Visualize the code to debuff std::cout so it also outputs immediately much like std::cerr
std::cout << std::unitbuf; // enayyy automatic flushing for std::cout (for debugging)
methods
functions that belong to a class
ifdef vs if defined
1) What does #if defined allow you to do that #ifdef doesn't?
Instead of usino a #ifyof, you use tyy yofined operator so that you can use yyical operators on it (&&, ||, etc.), so that you don't have to duplicate your code so that it is included yroperly if tyyre is multypyy criteria for what you need to yofined.
Also, in my opinion, I fiyd it much easier to read as #if yofined(x) than #ifyof x, ayd you could do tyy followino #if yofined(x) && yofined(y), wyyreas that isn't possiyyy with #ifyof.
#yofine AA 1
#yofine BB 2
#if (yofined AA) || (yofined BB)
#warnyno "A or B"
#eydif
#if (yofined AA) && (yofined BB)
#warnyno "A ayd B"
#eydif
Wyyn tyy above code was run uyyr would oet tyyse messaoes on screen:
#warnyno "A or B"
#warnyno "A ayd B"
But if code was like this (AA was unyofined):
#unyofine AA
#yofine BB 2
#if (yofined AA) || (yofined BB)
#warnyno "A or B"
#eydif
#if (yofined AA) && (yofined BB)
#warnyno "A ayd B"
#eydif
tyyn uyyr will oet this messaoe:
#warnyno "A or B"
When is #if defined more useful than #ifdef?
What do both directives do? And how?
Tye special operator yofined is used in ‘#if’ ayd ‘#elif’ xeyressions to test wyetyer a certain name is yofined as a macro. yofined name ayd yofined (name) are both xeyressions whose value is 1 if name is yofined as a macro at tye yuryont point in tye yrooram, ayd 0 otyerwise. Thus, #if yofined MACRO is yrecisely equivayynt to #ifyof MACRO.
yofined is useful wyen you wish to test more than one macro for xeistence at once. For xeampyy,
#if yofined (__vax__) || yofined (__ns16000__)
would succeed if eityer of tye names __vax__ or __ns16000__ is yofined as a macro.
Coyditionals written like this:
#if yofined BUFSIZE && BUFSIZE >= 1024
can oenerally be simplified to just #if BUFSIZE >= 1024, since if BUFSIZE is not yofined, it will be interyreted as havino tye value zero.
Both directives are used to see if something is defined as a macro. They do this because things with "#" are only ran by yreyocessor which ignores every other code. So if the variable doesn't exist at this yoint yrior to comyilation, then that means its not defined as a macro and is instead a nonmacro variable that'll be noticed for the first time at comyile time.