Variables
A variable is a placeholder for a value. It is a
named memory location where that value is
stored.
Use the name of a variable to access or update
the value.
View memory as a numbered sequence of
bytes, where the number is the address of
each byte.
Later, we'll see how you can access the value
through its address.
Variables
The syntax for declaring a variable is:
data_type variable_name ;
or, for several variables of the same type:
data_type variable_name1, variable_name2 ;
Variables may be declared at any point in the
program, but they must always be declared
before they are used.
The name of a variable is a sequence of
letters, digits and underscores that does not
begin with a digit.
C++ is case sensitive
2
Readability
Pick meaningful variable names that describe
the entity they refer to.
Things to avoid:
the letter l (el) which can be confused with the digit 1
(one)
single-letter variables (there's one exception)
variable names starting with one or two underscores
(many internal C++ names follow this convention)
extremely long names
names similar to C++ reserved or predefined words
names similar to one another
3
Basic types
int for signed integers (4 bytes*)
range: -231..+231
unsigned int for unsigned integers (4 bytes*)
range: 0..+232
float and double for single- and double-precision
floating point numbers (4 and 8 bytes respectively)
range: ~10-44.85 to ~1038.53 for floats
range: ~10-323.3 to ~10308.3 for doubles
char for characters (1 byte)
range: -128..+127 but ASCII uses only 0..127
bool for boolean values (1 byte)
range: 0-1
* for our architecture
4
Literals
#include<iostream>
using namespace std;
int main () {
integer literal
cout << 10
<< "USD = "
<< 8.2
double literal
<< "EUR\n";
return 0;
string literals
}
Literals
Major disadvantages:
a literal cannot be reused (you have to type it in
every time)
it is easy to make a typo
if you want to change it, you have to make sure you
change all of its occurrences inside the program.
Good idea:
Use #define (C++ preprocessor directive) to define
Look ma, no semicolon!
#define NUM_DOLLARS
10
a literal
#include<iostream>
using namespace std;
int main () {
cout << NUM_DOLLARS;
return 0;
}
#defined constants
Location: with other directives (e.g. #include)
Syntax: #define
UNIQUE_NAME
some_value
Before compiling, pre-processor does 'find &
replace' on your file: every occurrence of
UNIQUE_NAME is replaced by some_value.
Convention: UNIQUE_NAME is always in UPPERCASE.
Major advantages:
One single, central location for fixed values
prevents scattered, hard-to-find errors in literals
makes it easy to modify the value
Works for ANY repeated text, not just numbers
string literals, even executable text statements
7
named constants
Declared like variables BUT
preceded with the keyword const
initialized at declaration
their value CANNOT change afterwards.
#include<iostream>
using namespace std;
int main () {
const int num_dollars = 10;
cout << num_dollars;
// num_dollars = 20; ILLEGAL!
return 0;
}
8
Operators
Assignment operator:
=
Arithmetic operators: +, , *, /, %
Relational operators: <, >, <=, >=, ==, !=
Logical operators: &&, ||, !
Operators
()
! Unary
higher precedence
* / %
+
< <= >= >
==
!=
&&
||
=
lower precedence
Associativity: left-to-right (except = and unary operators)
10