introduction to c programming l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Introduction to C++ Programming PowerPoint Presentation
Download Presentation
Introduction to C++ Programming

Loading in 2 Seconds...

play fullscreen
1 / 85

Introduction to C++ Programming - PowerPoint PPT Presentation


  • 238 Views
  • Uploaded on

Introduction to C++ Programming . Csci 169 Prof.A.Bellaachia And Anasse Bari . Agenda Session 1 . 1. A Historical Perspective of C++ 2. Major Differences between C and C++ 3. Basics of C++ Structure of a program Variables and Data types Constants Operators

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Introduction to C++ Programming' - xiomara


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
introduction to c programming

Introduction to C++ Programming

Csci 169

Prof.A.Bellaachia

And

Anasse Bari

agenda session 1
Agenda Session 1

1. A Historical Perspective of C++

2. Major Differences between C and C++

3. Basics of C++

Structure of a program

Variables and Data types

Constants

Operators

Basic Input / output

4. Control Structures

Structures

Functions

5. Compound Data Types

Arrays

Characters

Pointers

Dynamic Memory

6. C++ and Object Oriented Programming

Classes

Objects

Constructors

Overloaded Constructors

Destructor

Copy Constructor

Inheritance ( Public and Private)

Function Overloading

Operator Overloading

Access Control

Friendship

Virtual Functions

Polymorphism

c historical perspective
C++ : Historical Perspective
  • What is C++ ?
  • Who invented C++ ?
  • Who are the users of C++ ?
c and c
C and C++
  • C is a Procedural Language :

“Decide which procedures you want; use the best algorithms you can find”

  • C++ is an Object Oriented Language:

“Decide which modules you want; partition the program so that data is hidden within modules”

  • C was chosen to be the base of C++ because:

1.C is versatile and terse

2.C is adequate for most systems programming tasks

3.C runs everywhere and on everything

basics of c
Basics of C++
  • Structure of a C++ program
  • Variables and Data types
  • Constants
  • Operators
  • Basic Input / output
our first c program
Our First C++ Program

// my first program in C++

#include <iostream.h>

Using namespace std;

int main ()

{

cout << “Hello Cs169 / Fall 2009 Students“;

return 0;

}

structure of a c program

Comment

Compilerdirectives

Specifies standard related names

Main portion of program.Contains C++ statements.

Structure of a C++ Program

/* greeting.cpp greets its user.

*

* Input: The name of the user

* Output: A personalized greeting

*********************************************************/

#include <iostream> // cin, cout, <<, >>

#include <string> // string

using namespace std;

int main()

{

cout << "Please enter your first name: ";

string firstName;

cin >> firstName;

cout << "\nWelcome to the world of C++, " << firstName << "!\n";

}

variables and data types
Variables and Data Types
  • Variable : a portion of memory to store a determined value.
  • How to distinguish variables ? Identifiers
  • Identifiers:
    • Combination of letters, digits, and underscores
    • Variable names should start with letter or digit
  • Important : C++ is a “case sensitive” language
more on variables
More on Variables
  • Declaration –
    • int number1;
    • float number2;
  • Initialization –
    • int number1 = 0;
    • int number2 = 3.3;
  • Assignment-
    • number1=5;
    • number2=number1;
scope of variables
Scope of Variables
  • Global Variables – variables that are declared above main() can be accessed anywhere after the declaration
  • LocalVariables – variables declared in section of code {}. Only accessible in that region.
initialization of variables
Initialization of Variables

Two possibilities:

  • type identifier = initial_value ;
  • type identifier (initial_value) ;
initialization of variables14
Initialization of Variables

// initialization of variables

#include <iostream.h>

Using namespace std;

int main ()

{

int x=5;

int y(2);

int result;

x = x + 3;

result = x - y

cout << result;

return 0;

}

characters and strings
Characters and Strings
  • ‘X’ is a character
  • “hello Cs169-Fall2009” is a string
  • C++ library provides support for strings :

string class

string mystring = "This is a string";

string mystring ("This is a string");

strings example
Strings Example

// my first string

#include <iostream>

#include <string>

using namespace std;

int main () {

string mystring;

mystring = “Hello Cs169, Fall 2009";

cout << mystring << endl;

mystring = “Hello Cs169, I wish you a great semester";

cout << mystring << endl;

return 0;

}

.

defined constants
Defined Constants
  • #define identifier value

#define PI 3.14159265

Example: Write a program that calculates the area and circumference of a Circle of Radius 10.

declared constants const
Declared Constants (const)
  • Use the “const” prefix you can declare constant with specific type

Examples:

    • const int radius = 100;
    • const char tabulator = '\t';
arithmetic operators
Arithmetic Operators

Assignment Operator ( = )

// assignment operator

#include <iostream>

using namespace std;

int main ()

{

int a, b; // a:?, b:?

a = 10; // a:10, b:?

b = 4; // a:10, b:4

a = b; // a:4, b:4

b = 7; // a:4, b:7

cout << "a:";

cout << a;

cout << " b:";

cout << b;

return 0;

}

arithmetic operators20
Arithmetic Operators

Compound assignment

Increment & Decrement ( ++,--)

Relational and equality operators ( ==, !=, >, <, >=, <= )

arithmetic operators21
Arithmetic Operators

Logical Operators ( !, &&, || )

arithmetic operators22
Arithmetic Operators
  • + addition
  • - subraction
  • * multiplication
  • / division
  • % modulo or remainder
basic c i o
Basic C++ I/O
  • “iostream” C++ library
  • Cout

cout << “Hello Cs169”; //Print Hello Cs169

cout << 120; // Print 120 on the screen

cout << x; // print the content of x in the screen

  • Cin

int age;

cin >> age;

cout << age

cin >> a >> b; is equivalent to cin>>a; cin>>b;

agenda session 124
Agenda Session 1

1. A Historical Perspective of C++

2. Major Differences between C and C++

3. Basics of C++

Structure of a program

Variables and Data types

Constants

Operators

Basic Input / output

4. Control Structures

Structures

Functions

5. Compound Data Types

Arrays

Characters

Pointers

Dynamic Memory

6. C++ and Object Oriented Programming

Classes

Friendship and Inheritance

Polymorphism

control structures
Control structures
  • if (cond) state1 else if (cond2) state2 else state3
  • while (expression) statement
  • do statement while (cond)
  • for (init; cond; increment) statement;
switch statement
Switch Statement

switch (x) { \

case 1:

cout << "x is 1";

break;

case 2:

cout << "x is 2";

break;

default:

cout << "value of x unknown";

}

functions
Functions
  • We can use functions to achieve structured programming

Int add(int a, int b){

a = a+b; return (a);

}

  • ‘int’ is the return type, ‘a’ and ‘b’ are arguments
  • When we call the function we must pass it parameters matching the arguments
passing parameters
Passing Parameters
  • Call By Value
    • This is what we usually do, we pass a function the value of a variable
  • Call By Reference
    • Instead of the value we will pass a pointer to the variable. If we modify the passed variable the change will be seen by the caller
    • We use ‘&parm’ to show that we are passing the variable at the memory location of parm
agenda session 132
Agenda Session 1

1. A Historical Perspective of C++

2. Major Differences between C and C++

3. Basics of C++

Structure of a program

Variables and Data types

Constants

Operators

Basic Input / output

4. Control Structures

Structures

Functions

5. Compound Data Types

Arrays

Characters

Pointers

Dynamic Memory

6. C++ and Object Oriented Programming

Classes

Friendship and Inheritance

Polymorphism

arrays
Arrays
  • An Array is a set of elements of the same type located in contiguous memory locations.
  • An Array can be referenced using index
arrays34
Arrays
  • Intialization
    • int numbers[5]={0,1,2,3,4,};
  • Accessing
    • num2 =numbers[1];
    • numbers[0]=99;
  • Passing arrays as parameters
    • Declaration: int add(int numarray[])
    • Call:

int array[]={1,2,3};

add(array);

pointers
Pointers
  • We used pointers in call by reference
  • A reference of a variable is the address that locates a variable in Memory
  • Pointer are Valuable in implementing data structures
address operator
Address Operator (&)
  • The ‘&’ operator returns the ‘address of’ its operand.
  • ‘&’ can be translated ‘address of’
dereference operator
Dereference Operator (*)

(*)  “Values pointed by”

  • Notice the difference:

& is the reference operator and can be read as "address of"

* is the dereference operator and can be read as "value pointed by”

sizeof
Sizeof()
  • The Sizeof() function is used to determine how many bytes of a data type during compilation.
  • Ex:

sizeof(float) equals 4

float array[10];

sizeof(array) equals 4*10 which is40

dynamic memory
Dynamic Memory
  • Dynamic Memory allows us to determine and allocate memory to variables and data structures at ‘run time’.
  • C++ uses new and delete;
    • pointer = new type;
      • New returns a pointer to the allocated memory
    • delete pointer;
      • Frees up the memory that was allocated
structs
Structs
  • Similar to records in Ada.

struct person_t{

char fname[20];

char lname[20];

int age;

}person1, person2;

  • Here we are declaring person1 and person2 as type person_t.
  • By convention we use the _t
accessing the struct members
Accessing the struct members
  • We use the ‘.’ to access members of a struct

cout << person1.fname;

person1.fname=“John”;

pointers to structs
Pointers to Structs
  • We can point to a struct like other structures.

Person_t* person1Ptr;

person1Ptr = &person1;

  • We can no longer use the ‘.’ to access the members in the struct we are pointing to.
    • The ‘->’ is used

Cout << person1Ptr->fname;

    • Element fname of structed pointed by person1Ptr
    • Same as *(person1Ptr.fname);
agenda session 147
Agenda Session 1

1. A Historical Perspective of C++

2. Major Differences between C and C++

3. Basics of C++

Structure of a program

Variables and Data types

Constants

Operators

Basic Input / output

4. Control Structures

Structures

Functions

5. Compound Data Types

Arrays

Characters

Pointers

Dynamic Memory

6. C++ and Object Oriented Programming

Classes

Objects

Constructors

Overloaded Constructors

Destructor

Copy Constructor

Inheritance ( Public and Private)

Function Overloading

Operator Overloading

Access Control

Friendship

Polymorphism

c classes
C++ Classes
  • A Class is User-defined type
  • An Object is an instance of a Class
  • A Class has :
    • Members Variables
    • Member Functions
    • Constructor
    • Destructor
constructors
Constructors
  • A Constructor is a member function that initializes an Object of a Class
  • A Constructor has the same name as the class it belongs to
  • A Constructor can be overloaded
  • The compiler select the correct one for each use
  • Good Practices:
  • Always define a constructor and always initialize all data members
  • If you do not create a constructor one is automatically defined (not recommended
  • Warning: attempting to initialize a data member of a class explicitly without using a constructors is a syntax error.
  • .
constructors example
ConstructorsExample

Class Date {

int d,m,y

Public:

//…

Date(int,int,int) //day,month, year

Date(int,int) //day, month, today’s year

Date(int) //day, today’s month and year

Date(); //default Date

Date(char*) // date in string representation

}

Date today(4);

Date july4(“july 4,1983)

Date guy(“5 nov”)

Date now;

destructors
Destructors
  • It is a member function which deletes an object.
  • A destructor function is called automatically when the object goes out of scope:

(1) the function ends

(2) the program ends

(3) a block containing temporary variables ends

(4) a delete operator is called 

  • A destructor has:

(i) the same name as the class but is preceded by a tilde (~)

(ii) no arguments and return no values

destructors53
Destructors
  • It is a member function which deletes an object.
  • A destructor function is called automatically when the object goes out of scope.

e.g. a block containing temporary variables ends

  • A destructor has the same name as the class but is preceded by a tilde (~)
  • A Destructor has no arguments and return no values
destructors example
DestructorsExample

class mystring {

private:

char *str;

int s; //size

public:

mystring(char *); // constructor

~mystring(); // destructor

};

mystring::mystring(char *c)

{

size = strlen(c);

str = new char[s+1];

strcpy(s,c);

}

mystring::~mystring()

{

delete []str;

}

copy constructor
Copy Constructor
  • A member function which initializes an object using another object of the same class.
  • Copy constructor prototype

myclass(const myname&);

copy constructor example
Copy ConstructorExample

class myrectangle{

private:

float height;

float width;

intx;

inty;

public:

rectangle(float, float); // constructor

rectangle(const myrectangle&); // copy constructor

void draw(); // draw member function

void posn(int, int); // position member function

void move(int, int); // move member function

};

importance of a copy constructors
Importance of a copy constructors
  • In the absence of a copy constructor, the C++ compiler builds a default copy constructor for each class which is doing a memberwise copy between objects.
  • Default copy constructors work fine unless the class contains pointer data members ... why???
slide58
#include <iostream.h>

#include <string.h>

class mystring{

private:

char *s;

int size;

public:

mystring(char *); // constructor

~mystring(); // destructor

void print();

void copy(char *);

};

void mystring::print()

{

cout << s << endl;

}

slide59
void string::copy(char *c)

{

strcpy(s, c);

}

void main()

{

string str1("George");

string str2 = str1; // default copy constructor

str1.print(); // what is printed ?

str2.print();

str2.copy("Mary");

str1.print(); // what is printed now ?

str2.print();

}

defining a copy constructor
Defining a copy constructor

class mystring{

private:

char *s;

int size;

public:

mystring(char *); // constructor

~mystring(); // destructor

string(const mystring&); // copy constructor

void print();

void copy(char *);

};

slide61
string::string(const string& old_str)

{

size = old_str.size;

s = new char[size+1];

strcpy(s,old_str.s);

}

void main()

{

string str1("George");

string str2 = str1;

str1.print(); // what is printed ?

str2.print();

str2.copy("Mary");

str1.print(); // what is printed now ?

str2.print();

}

-- same results can be obtained by overloading the assignment operator.

inheritance
Inheritance
  • Objects are often defined in terms of hierarchical classes with a base class and one or more levels of classes that inherit from the classes that are above it in the hierarchy.
  • For instance, graphics objects might be defined as follows:
inheritance63
Inheritance
  • This hierarchy could, of course, be continued for more levels.
  • Each level inherits the attributes of the above level. Shape is the base class. 2-D and 3-D are derived from Shape and Circle, Square, and Triangle are derived from 2-D. Similarly, Sphere, Cube, and Tetrahedron are derived from 3-D.
inheritance64
Inheritance

class A : base class access specifier B

{

member access specifier(s):

...

member data and member function(s);

...

}

Valid access specifiers include public, private, and protected

public inheritance
Public Inheritance

class A : public B

{ // Class A now inherits the members of Class B

// with no change in the “access specifier” for

} // the inherited members

public base class (B)

public members

protected members

private members

derived class (A)

public

protected

inherited but not accessible

private inheritance
Private Inheritance

class A : private B

{ // Class A now inherits the members of Class B

// with public and protected members

} // “promoted” to private

private base class (B)

public members

protected members

private members

derived class (A)

private

private

inherited but not accessible

inheritance continued
Inheritance (continued)

class Shape

{

public:

int GetColor ( ) ;

protected: // so derived classes can access it

int color;

};

class Two_D : public Shape

{

// put members specific to 2D shapes here

};

class Three_D : public Shape

{

// put members specific to 3D shapes here

};

Winter Quarter

inheritance continued68
Inheritance (continued)

class Square : public Two_D

{

public:

float getArea ( ) ;

protected:

float edge_length;

} ;

class Cube : public Three_D

{

public:

float getVolume ( ) ;

protected:

float edge_length;

} ;

inheritance69
Inheritance

int main ( )

{

Square mySquare;

Cube myCube;

mySquare.getColor ( ); // Square inherits getColor()

mySquare.getArea ( );

myCube.getColor ( ); // Cube inherits getColor()

myCube.getVolume ( );

}

function overloading
Function Overloading
  • C++ supports writing more than one function with the same name but different argument lists. This could include:
    • different data types
    • different number of arguments
  • The advantage is that the same apparent function can be called to perform similar but different tasks. The following will show an example of this.
function overloading71
Function Overloading

void swap (int *a, int *b) ;

void swap (float *c, float *d) ;

void swap (char *p, char *q) ;

int main ( )

{

int a = 4, b = 6 ;

float c = 16.7, d = -7.89 ;

char p = 'M' , q = 'n' ;

swap (&a, &b) ;

swap (&c, &d) ;

swap (&p, &q) ;

}

function overloading72
Function Overloading

void swap (int *a, int *b)

{ int temp; temp = *a; *a = *b; *b = temp; }

void swap (float *c, float *d)

{ float temp; temp = *c; *c = *d; *d = temp; }

void swap (char *p, char *q)

{ char temp; temp = *p; *p = *q; *q = temp; }

operator overloading
Operator Overloading
  • C++ already has a number of types (e.g., int, float, char, etc.) that each have a number of built in operators. For example, a float can be added to another float and stored in yet another float with use of the + and = operators:

floatC = floatA + floatB;

  • In this statement, floatB is passed to floatA by way of the + operator. The + operator from floatA then generates another float that is passed to floatC via the = operator. That new float is then stored in floatC by some method outlined in the = function.
operator overloading74
Operator Overloading
  • Operator overloading means that the operators:
    • Have multiple definitions that are distinguished by the types of their parameters, and
    • When the operator is used, the C++ compiler uses the types of the operands to determine which definition should be used.
operator overloading continued
Operator Overloading (continued)
  • A programmer has the ability to re-define or change how the operators (+, -, *, /, =, <<, >>, etc.) work on their own classes.
  • Overloading operators usually consists of defining a class member function called operator+ (where + is any operator). Note that operator is a reserved word in C++. If anything usually follows that operator, it is passed to the function. That function acts exactly like any other member function; it has the same scope as other member functions and can return a value just like any other member function.
operator overloading76
Operator Overloading

Steps for defining an overloaded operator:

1. Name the operator being overloaded.

2. Specify the (new) types of parameters (operands) the operator is to receive.

3. Specify the type of value returned by the operator.

4. Specify what action the operator is to perform.

friendship
Friendship
  • A friend function of a class is defined outside the class’s scope (I.e. not member functions), yet has the right to access the non-public members of the class.
  • Single functions or entire classes may be declared as friends of a class.
  • These are commonly used in operator overloading. Perhaps the most common use of friend functions is overloading << and >> for I/O.
friends
Friends
  • Basically, when you declare something as a friend, you give it access to your private data members.
  • This is useful for a lot of things – for very interrelated classes, it more efficient (faster) than using tons of get/set member function calls, and they increase encapsulation by allowing more freedom is design options.
friends79
Friends
  • A class doesn't control the scope of friend functions so friend function declarations are usually written at the beginning of a .h file. Public and private don't apply to them.
friends80
Friends
  • Friendship is not inherited, transitive, or reciprocal.
    • Derived classes don’t receive the privileges of friendship (more on this when we get to inheritance in a few classes)
    • The privileges of friendship aren’t transitive. If class A declares class B as a friend, and class B declares class C as a friend, class C doesn’t necessarily have any special access rights to class A.
    • If class A declares class B as a friend (so class B can see class A’s private members), class A is not automatically a friend of class B (so class A cannot necessarily see the private data members of class B).
polymorphism compile time binding vs run time binding
Polymorphism Compile-Time Binding vs. Run-Time Binding
  • A function’s name is associated with an entry point, the starting address of the code that implements the function
  • Compile-time binding lets the compiler determines what code is to be executed when a function name is invoked
  • Run-time binding is the binding of a function’s name to an entry point when the program is running
compile time binding
Compile-Time Binding

#include <iostream>

using namespace std;

void sayHi();

int main() {

sayHi();

return 0;

}

void sayHi() {

cout <<"Hello, cruel world!"<< endl;

}

requirements for c polymorphism
Requirements for C++ Polymorphism
  • There must be an inheritance hierarchy
  • The classes in the hierarchy must have a virtual method with the same signature
  • There must be either a pointer or a reference to a base class. The pointer or reference is used to invoke a virtual method