0% found this document useful (0 votes)
12 views30 pages

Basics

Uploaded by

pardhualiasnandu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
12 views30 pages

Basics

Uploaded by

pardhualiasnandu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 30

C++ Basics

Lecture 2
COP 3014 Fall 2018

August 27, 2018


Structure of a C++ Program

I Sequence of statements, typically grouped into functions.


I function: a subprogram. a section of a program performing a
specific task.
I Every function body is defined inside a block.
I For a C++ executable, exactly one function called main()
I Can consist of multiple files and typically use libraries.
I Statement: smallest complete executable unit of a program.
I Declaration statement
I Execution statement
I Compound statement – any set of statements enclosed in set
braces { } (often called a block)
I Simple C++ statments end with a semi-colon. (A block does
not typically need a semi-colon after it, except in special
circumstances).
Libraries
Libraries

I Usually pre-compiled code available to the programmer to


perform common tasks
I Compilers come with many libraries. Some are standard for all
compilers, and some may be system specific.
I Two parts
I Interface: header file, which contains names and declarations
of items available for use
I Implementation: pre-compiled definitions, or implementation
code. In a separate file, location known to compiler
I Use the #include directive to make a library part of a program
(satisfies declare-before-use rule)
Building and Running a C++ Program

I Starts with source code, like the first sample program


I Pre-processing
I The #include directive is an example of a pre-processor
directive (anything starting with #).
I #include <iostream>tells the preprocessor to copy the
standard I/O stream library header file into the program
I Compiling
I Syntax checking, translation of source code into object code
(i.e. machine language). Not yet an executable program.
I Linking
I Puts together any object code files that make up a program,
as well as attaching pre-compiled library implementation code
(like the standard I/O library implementation, in this example)
I End result is a final target – like an executable program
I Run it!
Typical Code Elements

I Comments - Ignored by the Compiler


I Directives - For preprocessing
I Literals - Hardcoded values. Eg: 10
I Keywords - Words with special meaning to the compiler. Eg:
int
I Identifiers - Names for variables, functions, etc.
I Operators - Symbols that perform certain operations. Eg: +
Comments

I Comments are for documenting programs. They are ignored


by the compiler.
I Block style (like C)
/* This is a comment.
It can span multiple lines */
I Line comments – use the double-slash //
int x; // This is a comment
x = 3; // This is a comment
Data Types
Atomic data types are the built-in types defined by the C++
language.
I bool: has two possible values, true or false
I integer types
I char - 1 byte on most systems.
I Typically used for representing characters
I Stored with an integer code underneath (ASCII on most
computers today)
I short - (usually at least 2 bytes)
I int - (4 bytes on most systems)
I long - (usually 4 or more bytes)
I The integer types have regular and unsigned versions
I floating point types - for storage of decimal numbers (i.e. a
fractional part after the decimal)
I float
I double
I long double
Identifiers

Identifiers are the names for things (variables, functions, etc) in the
language. Some identifiers are built-in, and others can be created
by the programmer.
I User-defined identifiers can consist of letters, digits, and
underscores
I Must start with a non-digit
I Identifiers are case sensitive (count and Count are different
variables)
I Reserved words (keywords) cannot be used as identifiers
Style Conventions for Identifiers

I Don’t re-use common identifiers from standard libraries (like


cout, cin)
I Start names with a letter, not an underscore. System
identifiers and symbols in preprocessor directives often start
with the underscore.
I Pick meaningful identifiers – self-documenting

numStudents, firstName // good


a, ns, fn // bad
I a couple common conventions for multiple word identifiers
I numberOfMathStudents
I number of math students
Declaring Variables

I Declare Before Use: Variables must be declared before they


can be used in any other statements
I Declaration format:
typeName variableName1, variableName2, ...;

int numStudents; // variable of type integer


double weight; // variable of type double
char letter; // variable of type character

//Examples of multiple variables of the same type


//in single declaration statements

int test1, test2, finalExam;


double average, gpa;
Initializing Variables
I To declare a variable is to tell the compiler it exists, and to
reserve memory for it
I To initialize a variable is to load a value into it for the first
time
I If a variable has not been initialized, it contains whatever bits
are already in memory at the variable’s location (i.e. a
garbage value)
I One common way to initialize variables is with an assignment
statement. Examples:
int numStudents;
double weight;
char letter;

numStudents = 10;
weight = 160.35;
letter = ‘A’;
Initializing Variables

I Variables of built-in types can be declared and initialized on


the same line, as well

int numStudents = 10;


double weight = 160.35;
char letter = ‘A’;

int test1 = 96, test2 = 83, finalExam = 91;


double x = 1.2, y = 2.4, z = 12.9;
Initializing Variables

An alternate form of initializing and declaring at once:

// these are equivalent to the ones above


int numStudents(10);
double weight(160.35);
char letter(‘A’);

int test1(96), test2(83), finalExam(91);


double x(1.2), y(2.4), z(12.9);
Constants
Constants

I A variable can be declared to be constant. This means it


cannot change once it’s declared and initialized
I Use the keyword const
I MUST declare and initialize on the same line
const int SIZE = 10;
const double PI = 3.1415;

// this one is illegal, because it’s not


// initialized on the same line
const int LIMIT; // BAD!!!
LIMIT = 20;
I A common convention is to name constants with all-caps (not
required)
Symbolic Constants (an alternative)

I A symbolic constant is created with a preprocessor directive,


#define. (This directive is also used to create macros).
I Examples:
#define PI 3.14159
#define DOLLAR ‘$’
#define MAXSTUDENTS 100
I The preprocessor replaces all occurrences of the symbol in
code with the value following it. (like find/replace in MS
Word).
I This happens before the actual compilation stage begins
Literals

I Literals are also constants. They are literal values written in


code.
I integer literal – an actual integer number written in code (4,
-10, 18)
I If an integer literal is written with a leading 0, it’s interpreted
as an octal value (base 8).
I If an integer literal is written with a leading 0x, it’s interpreted
as a hexadecimal value (base 16)
I Example:
int x = 26; // integer value 26
int y = 032; // octal 32 = decimal value 26
int z = 0x1A; // hex 1A = decimal value 26
More Literals

I floating point literal – an actual decimal number written in


code (4.5, -12.9, 5.0)
I These are interpreted as type double by standard C++
compilers
I Can also be written in exponential (scientific) notation:
(3.12e5, 1.23e-10)
I character literal – a character in single quotes: (‘F’, ‘a’, ‘\n’)
I string literal – a string in double quotes: (“Hello”, “Bye”,
“Wow!\n”)
I boolean literals - true or false
Escape Sequences
I String and character literals can contain special escape
sequences
I They represent single characters that cannot be represented
with a single character from the keyboard in your code
I The backslash \is the indicator of an escape sequence. The
backslash and the next character are together considered ONE
item (one char)
I Some common escape sequences are listed in the table below

Escape Sequence Meaning


\n newline
\t tab
\” double quote
\’ single quote
\\ backslash
Input and Output Streams

I In C++ we use do I/O with “stream objects”, which are tied


to various input/output devices.
I These stream objects are predefined in the iostream library.
I cout – standard output stream
I Of class type ostream (to be discussed later)
I Usually defaults to the monitor
I cin – standard input stream
I Of class type istream (to be discussed later)
I Usually defaults to the keyboard
I cerr – standard error stream
I Of class type ostream
I Usually defaults to the monitor, but allows error messages to
be directed elsewhere (like a log file) than normal output
Using Streams

I To use these streams, we need to include the iostream library


into our programs.

#include <iostream>
using namespace std;

I The using statement tells the compiler that all uses of these
names (cout, cin, etc) will come from the ”standard”
namespace.
Using the Output Stream

I output streams are frequently used with the insertion


operator <<
I Format:
outputStreamDestination <<itemToBePrinted
I The right side of the insertion operator can be a variable, a
constant, a value, or the result of a computation or operation
I Examples:
cout <<‘‘Hello World"; // string literal
cout <<‘a’; // character literal
cout <<numStudents; // contents of a variable
cout <<x + y - z; // result of a computation
cerr <<‘‘Error occurred"; // string literal
printed to standard error
Cascading Output

I When printing multiple items, the insertion operator can be


“cascaded”.
I Cascading is placing another operator after an output item to
insert a new output item.
cout <<‘‘Average = " <<avg <<‘\n’;
cout <<var1 <<‘\t’ <<var2 <<‘\t’ <<var3;
I We won’t utilize cerr in this course. It’s less common than
cout esp. in intro programming, but here for completeness.
Input Streams

I input streams are frequently used with the extraction


operator >>
I Format:
inputStreamSource >>locationToStoreData
I The right side of the extraction operator MUST be a memory
location. For now, this means a single variable!
I By default, all built-in versions of the extraction operator will
ignore any leading “white-space” characters (spaces, tabs,
newlines, etc)
I In case if strings, the extraction operator will keep reading
until it encounters a white space character.
Examples

int numStudents;
cin >>numStudents; // read an integer

double weight;
cin >>weight; // read a double

cin >>‘\n’; // ILLEGAL. Right side must be a


variable
cin >>x + y; // ILLEGAL. x + y is a computation, not
a variable

The extraction operator can be cascaded, as well:


int x, y;
double a;
cin >>x >>y >>a; // read two integers and a double
from input
Some special formatting for decimal numbers

You will need the iomanip library for this.


I By default, decimal (floating-point) numbers will print in
standard notation while possible, using scientific notation only
when the numbers are too small or too large.
I Usually, cout prints out floats only as far as needed, up to a
certain preset number of decimal places (before rounding the
printed result).
double x = 4.5, y = 12.666666666666, z = 5.0;

cout <<x; // will likely print 4.5


cout <<y; // will likely print 12.6667
cout <<z; // will likely print 5
Magic Formula

I A special “magic formula” for controlling how many decimal


places are printed:

cout.setf(ios::fixed); //fixed point notation

cout.setf(ios::showpoint);
// so that decimal point will always be shown

cout.precision(2);
// sets floating point types to print to 2
decimal places (or use your desired number)

cout.setf(ios::scientific);
// float types formatted in exponential notation
Magic Formula

I Any cout statements following these will output floating-point


values in the usual notation, to 2 decimal places.

double x = 4.5, y = 12.666666666666, z = 5.0;

cout <<x; // prints 4.50


cout <<y; // prints 12.67
cout <<z; // prints 5.00
I These statements use what are called stream manipulators,
which are symbols defined in the iostream library as shortcuts
for setting those particular formatting flags
Alternate Method

I Here’s an alternate way to set the “fixed” and “showpoint”


flags

cout <<fixed;
// uses the "fixed" stream manipulator

cout <<showpoint;
// uses the "showpoint" stream manipulator

cout <<setprecision(3); // uses the set


precision stream manipulator (you’ll need the
iomanip library for this)

//The above sets precision of the value to 3


numbers. You can change this value based on what
you need.

You might also like