1 Compiled Languages and C++: 1.1 Why Use A Language Like C++?
1 Compiled Languages and C++: 1.1 Why Use A Language Like C++?
Introduction
1
1.1
At its core, a computer is just a processor with some memory, capable of running tiny
instructions like store 5 in memory location 23459. Why would we express a program
as a text file in a programming language, instead of writing processor instructions?
The advantages:
1. Conciseness: programming languages allow us to express common sequences of
com mands more concisely. C++ provides some especially powerful shorthands.
2. Maintainability: modifying code is easier when it entails just a few text edits,
instead of rearranging hundreds of processor instructions. C++ is object
oriented (more on that in Lectures 7-8), which further improves maintainability.
3. Portability: di erent processors make di erent instructions available. Programs writ
ten as text can be translated into instructions for many di erent processors; one of
C++s strengths is that it can be used to write programs for nearly any processor.
C++ is a high-level language: when you write a program in it, the shorthands are su ciently
expressive that you dont need to worry about the details of processor instructions. C++ does
give access to some lower-level functionality than other languages (e.g. memory addresses).
SourceFile
Compiler
Compiler
ObjectFile
ObjectFile
Linker
Libraries
Executable
OS
PrograminMemory
Object files are intermediate files that represent an incomplete copy of the program: each
source file only expresses a piece of the program, so when it is compiled into an object file,
the object file has some markers indicating which missing pieces it depends on. The linker
takes those object files and the compiled libraries of predefined code that they
rely on, fills in all the gaps, and spits out the final program, which can then be run
by the operating system (OS).
The compiler and linker are just regular programs. The step in the compilation
process in which the compiler reads the file is called parsing.
In C++, all these steps are performed ahead of time, before you start running a program.
In some languages, they are done during the execution process, which takes time. This is
one of the reasons C++ code runs far faster than code in many more recent languages.
C++ actually adds an extra step to the compilation process: the code is run
through a preprocessor, which applies some modifications to the source code,
before being fed to the compiler. Thus, the modified diagram is:
Preprocessor
SourceFile
Compiler
ProcessedCode
ObjectFile
Linker
OS
Executable
Preprocessor
SourceFile
1.3
Compiler
ProcessedCode
PrograminMemory
Libraries
ObjectFile
C++ is immensely popular, particularly for applications that require speed and/or access
to some low-level features. It was created in 1979 by Bjarne Stroustrup, at first as a set
of extensions to the C programming language. C++ extends C; our first few lectures will
basically be on the C parts of the language.
Though you can write graphical programs in C++, it is much hairier and less portable than
text-based (console) programs. We will be sticking to console programs in this course.
Everything in C++ is case sensitive: someName is not the same as SomeName.
Hello World
In the tradition of programmers everywhere, well use a Hello, world! program as an entry
point into the basic features of C++.
2.1
The code
Hello
World
program
1 // A
#
include
<iostream
>
2
3
2
main () {
4 int
std :: cout << "Hello , world !\n" ;
5
6
return 0;
7
8 }
2.2 Tokens
Tokens are the minimals chunk of program that have meaning to the compiler
the smallest meaningful symbols in the language. Our code displays all 6 kinds of
tokens, though the usual use of operators is not present here:
Token type
Description/Purpose
Examples
Whitespace
4. int main() {...} defines the code that should execute when the
program starts up. The curly braces represent grouping of multiple
commands into a block. More about this syntax in the next few lectures.
5.
cout
<<
This is the syntax for outputting some piece of text to the screen.
namespace
std;
This line tells the compiler that it should look in the std namespace for
any identifier we havent defined. If we do this, we can omit the std::
prefix when writing cout. This is the recommended practice.
Strings: A sequence of characters such as Hello, world is known as a
Escape Sequence
Represented Character
\a
\b
Backspace
\f
\n
\r
\t
Tab
\\
Backslash
\"
\some integer x
7. return 0 indicates that the program should tell the operating system it has
Note that every statement ends with a semicolon (except preprocessor commands and blocks
using {}). Forgetting these semicolons is a common mistake among new C++ programmers.
Not every statement is an expression. It makes no sense to talk about the value of
an #include statement, for instance.
3.2
Operators
Operator types:
Mathematical: +, -, *, /, and parentheses have their usual mathematical
meanings, including using - for negation. % (the modulus operator) takes the
remainder of two numbers: 6 % 5 evaluates to 1.
Logical: used for and, or, and so on. More on those in the next lecture.
Bitwise: used to manipulate the binary representations of numbers. We will
not focus on these.
3.4
Data Types
Every expression has a type a formal description of what kind of data its value is. For instance, 0
is an integer, 3.142 is a floating-point (decimal) number, and "Hello, world!\n"
Type Names
Description
Size
char
int
Larger integer.
bool
double
Range
signed: -128 to 127
unsigned: 0 to 255
4 bytes signed:
-2147483648 to
2147483647
unsigned: 0 to 4294967295
Boolean (true/false).
Indi 1 byte Just true (1) or false (0).
cated with the keywords true
and false.
Doubly precise
point number.
The sizes/ranges for each type are not fully standardized; those shown
above are the ones used on most 32-bit computers.
An operation can only be performed on compatible types. You can add 34 and 3,
but you cant take the remainder of an integer and a floating-point number.
An operator also normally produces a value of the same type as its operands;
thus, 1 / 4 evaluates to 0 because with two integer operands, / truncates the
result to an integer. To get 0.25, youd need to write something like 1 / 4.0.
A text string, for reasons we will learn in Lecture 5, has the type char
*.
Variables
We might want to give a value a name so we can refer to it later. We do this using variables.
A variable is a named location in memory.
For example, say we wanted to use the value 4
use it as follows:
<iostream >
1 # include
namespace std ;
2 using
3
{
4 int main ()
int
x;
5
x
=
4
+ 2;
6
7
cout << x / 3 << <<
8
9
return
0;
11 }
2;
(Note how we can print a sequence of values by chaining the << symbol.)
The name of a variable is an identifier token. Identifiers may contain numbers,
letters, and underscores ( ), and may not start with a number.
Line 4 is the declaration of the variable x. We must tell the compiler what type x
will be so that it knows how much memory to reserve for it and what kinds of
operations may be performed on it.
Line 5 is the initialization of x, where we specify an initial value for it. This
introduces a new operator: =, the assignment operator. We can also change the
value of x later on in the code using this operator.
We could replace lines 4 and 5 with a single statement that does both declaration
and initialization:
int
2;
5 Input
Now that we know how to give names to values, we can have the user of the
program input values. This is demonstrated in line 6 below:
1 # include<iostream >
2 using namespace std ;
3
main () {
4 int
int
x;
5
cin >> x;
6
7
cout << x / 3 << << x * 2;
8
9
10
return
0;
11 }
Just as cout << is the syntax for outputting values, cin >> (line 6) is the syntax
for inputting values.
Memory trick: if you have trouble remembering which way the angle brackets go
for cout and cin, think of them as arrows pointing in the direction of data flow.
cin represents the terminal, with data flowing from it to your variables; cout
likewise represents the terminal, and your data flows to it.
6 Debugging
There are two kinds of errors youll run into when writing C++ programs: compilation
errors and runtime errors. Compilation errors are problems raised by the compiler,
generally resulting from violations of the syntax rules or misuse of types. These are often
caused by typos and the like. Runtime errors are problems that you only spot when you
run the program: you did specify a legal program, but it doesnt do what you wanted it to.
These are usually more tricky to catch, since the compiler wont tell you about them.