lecture1 pf.pptx

Programing Fundamentals
C++ Programming Basics
Hafiz Ali Ahmed
ali.ahmed@superior.edu.pk
Superior University, Lahore

Explanation:
This program consists of a single
function called main().
Because of the parentheses()
the compiler comes to know that
this is a function not a variable.
The parentheses aren’t always
empty. They’re used to hold
function arguments
(values passed from the calling program to the function).
Line number 2, 3 are not part of the function.
The word int preceding the function name indicates that this particular
function has a return value of type int.
//main.cpp
#include <iostream>
using namespace std;
int main(){
cout << "Welcome to this course";
return 0;
}
1
2
3
4
5
6
7
8
9

The body of a function is surrounded by
braces (sometimes called curly brackets).
Every function must use this pair of braces
around the function body.
A function body can consist of many
statements but this function has only
2 statements
You can put several statements on one line and one statement in over two or
more lines.
//main.cpp
#include <iostream>
int main(){
cout << "Welcome to this coursen";
return 0;
}
1
2
3
4
5
6
7
8
9
cout
<<"Welcome to this coursen"
;
1
2
3
cout <<"Welcome Studentsn" ; return 0;
1

We don’t recommend these syntax. it’s
nonstandard and hard to read. but it does
compile correctly.
#include is a preprocessor directive, which
must be written on one line.
#include <iostream> tells the compiler to first
include standard C++ library named iostream to our project.
A string constant "Welcome to this coursen" can also be broken into separate
lines if u insert a backslash () at the line break or divide the string into two
separate strings, each surrounded by quotes.
A programs may consists of many functions but the
main() function will be executed first.
//main.cpp
#include <iostream>
int main(){
return 0;
}
1
2
3
4
5
6
7
8
9
cout
<<"Welcome
to this
coursen"
;
cout
<<"Welcome "
"to this "
"coursen"
;

If there is no function called main() in your
program, an error will be reported when you
run the program.
main function may also call other functions.
There are three statements this program
return 0;
The first statement tells the computer to display the quoted phrase.
A semicolon ; signals the end of the statement. If you leave out the
semicolon, the compiler will often signal an error.
//main.cpp
#include <iostream>
int main(){
return 0;
}
1
2
3
4
5
6
7
8
9

cout <<"Welcome to this coursen";
The identifier cout (pronounced “C out”) is
actually an object. It is predefined in C++ to
correspond to the standard output stream.
A stream is an abstraction that refers to a
flow of data. The standard output stream
normally flows to the screen display although
it can be redirected to other output devices.
The operator << is called the insertion or put to operator. It directs the
contents of the variable on its right to the object on its left.
In our program it directs the string constant "Welcome to this coursen" to
cout, which sends it to the display.
//main.cpp
#include <iostream>
int main(){
return 0;
}
1
2
3
4
5
6
7
8
9

In C++, operators can be overloaded. That is, they can perform different
activities, depending on the context.
 The phrase in quotation marks, "Welcome to this coursen", is an example of
a string constant.
 A constant, unlike a variable, cannot be given a new value as the program
runs. Its value is set when the program is written, and it retains this value
throughout the program’s existence.
 The 'n' character at the end of the string constant is an example of an escape
sequence. The 'n' causes the next text output to be displayed on a new line.

Line no. 2, 3 and 4 in our program are called
directives.
The first is preprocessor
directive, and the second is a using directive.
Preprocessor Directives
#include <iostream>
This is not a program statement or a part of a function body. It starts with a
number sign (#). It’s called a preprocessor directive.
A preprocessor directive is an instruction to the compiler.
A part of the compiler called the preprocessor deals with these directives
before it begins the real compilation process.
//main.cpp
#include <iostream>
int main(){
return 0;
}
1
2
3
4
5
6
7
8
9

The preprocessor directive #include tells the compiler to insert another file
into your source file. In effect, the #include directive is replaced by the
contents of the file indicated.
Using an #include directive to insert another file into your source file is similar
to pasting a block of text into a document with your word processor.
#include is only one of many preprocessor directives, all of which can be
identified by the initial # sign.
The type file usually included by #include is called a header file.

In our program the preprocessor directive #include tells the compiler to add
the source file iostream to the main.cpp source file before compiling.
iostream is example of a header file.
Iostream is concerned with basic input/output operations, and contains
declarations that are needed by the cout identifier and the << operator.
Without these declarations, the compiler won’t recognize cout and will think
<< is being used incorrectly.
The newer Standard C++ header files don’t have a file extension, but some
older header files have the extension .H.

A C++ program can be divided into different namespaces. A namespace is a
part of the program in which certain names are recognized; outside of the
namespace they’re unknown.
The directive using namespace std; says that all the program statements that
follow are within the std namespace.
Various program components such as cout are declared within this
namespace. If we didn’t use the using directive, we would need to add the std
name to many program elements. e.g.
std::cout << "Welcome to this coursen";
To avoid adding std:: dozens of times in programs we use the using directive
instead.

lecture1 pf.pptx

More Related Content

Similar to lecture1 pf.pptx (20)

Recently uploaded (20)

lecture1 pf.pptx