SlideShare a Scribd company logo

Advanced CPP Lecture 1- Summer School 2014 - ACA CSE IITK

Pankaj Prateek, profile picture
Pankaj Prateek

This document provides information about an Advanced C++ summer school course including details about the course schedule, evaluation criteria, prerequisites, and an introduction to structures and classes in C++. The course will be held from June 23-27, 2014 from 2:30-4:00 pm daily. Evaluation will be based 50% on an end of semester exam and 50% on assignments and in-class quizzes. A good command of C/C++, pointers, and structures is required. The document then provides information on using structures and classes to organize data in C++ programs.

EngineeringTechnologyEducation
1 of 68
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
ACA Summer School 2014 Advanced C++ Pankaj Prateek ACA, CSE, IIT Kanpur June 23, 2014
Course website: http: //www.cse.iitk.ac.in/users/aca/sumschool2014.html Evaluation End Sem - 50% Assignments / In-class quiz - 50% Timings: M-F 1430 - 1600 hrs
Prerequisites A good command over any programming language preferably C/C++ Pointers Structures
Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
Structures Usage struct Person p1; struct Person p2; Accessing Members: p1.name = ‘‘pankaj ’’; p1.nBirthDay = 20; p2.name = ‘‘Rahul ’’;
Structures Usage struct Person p1; struct Person p2; Accessing Members: p1.name = ‘‘pankaj ’’; p1.nBirthDay = 20; p2.name = ‘‘Rahul ’’;
Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
Classes Extension of structures Class Definition class class_name { private: variable declarations; function declarations; public: variable declarations; function declarations; }; //DO NOT forget the semicolon
Classes Extension of structures Class Definition class class_name { private: variable declarations; function declarations; public: variable declarations; function declarations; }; //DO NOT forget the semicolon
Class: Example Example class item { private: int number; // variable declarations float cost; // private by default! public: // function declarations through prototypes void getData(int a, float b); void putData(void ); }
Class No memory allocated for a class definiton. It is only a “template”, like a definition of a structure
Class: Public and Private Private members are not directly accessible outside the class. They are “hidden” from the outside world. The only way to access them is by using public functions (if defined) which manipulate them. Public members can be accessed using the dot operator (member selection operator). Eg. student.name, item.getData()
Class: Public and Private Private members are not directly accessible outside the class. They are “hidden” from the outside world. The only way to access them is by using public functions (if defined) which manipulate them. Public members can be accessed using the dot operator (member selection operator). Eg. student.name, item.getData()
Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
Class: Function definitions Outside the class class Employee { int empno , salary; public: void set(int roll , int sal); }; void employee ::set(int roll , int sal) { empno = roll; salary = sal; }
Class: Function definitions Outside the class class Employee { int empno , salary; public: void set(int roll , int sal); }; void employee ::set(int roll , int sal) { empno = roll; salary = sal; }
Class: Function definitions Inside the class class Employee { int empno , salary; public: void set(int roll , int sal) { empno = roll; salary = sal; } };
Class: Function definitions Inside the class class Employee { int empno , salary; public: void set(int roll , int sal) { empno = roll; salary = sal; } };
Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
Static Members class item { static int count; // rest of class definition }; int item :: count;
Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
Memory Allocation of Objects For member functions and static variables, memory is allocated when the class is defined, all objects of the class share the same function code and static variables (every class does not get its own copy). “this” pointer is implicitly passed so that the function code is executed on the correct class instance. For variables, memory is allocated when the object is defined. Each instance gets its own set of variables.
Memory Allocation of Objects For member functions and static variables, memory is allocated when the class is defined, all objects of the class share the same function code and static variables (every class does not get its own copy). “this” pointer is implicitly passed so that the function code is executed on the correct class instance. For variables, memory is allocated when the object is defined. Each instance gets its own set of variables.
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
References The C++ Programming Language - Bjarne Stroustrup Object Oriented Programming with C++ - E Balaguruswamy http://www.cplusplus.com/reference http://www.learncpp.com/ http://www.java2s.com/Code/Cpp/CatalogCpp.htm

More Related Content

PDF
Advanced CPP Lecture 2- Summer School 2014 - ACA CSE IITK
Pankaj Prateek
 
DOCX
Introduction to object oriented programming concepts
Ganesh Karthik
 
PPT
Defining classes-and-objects-1.0
BG Java EE Course
 
PPTX
Classes and objects1
Vineeta Garg
 
PPTX
[OOP - Lec 13,14,15] Constructors / Destructor and its Types
Muhammad Hammad Waseem
 
PPT
Java: Objects and Object References
Tareq Hasan
 
PPTX
Object Oriended Programming with Java
Jakir Hossain
 
PPT
Unidad o informatica en ingles
Marisa Torrecillas
 
Advanced CPP Lecture 2- Summer School 2014 - ACA CSE IITK
Pankaj Prateek
 
Introduction to object oriented programming concepts
Ganesh Karthik
 
Defining classes-and-objects-1.0
BG Java EE Course
 
Classes and objects1
Vineeta Garg
 
[OOP - Lec 13,14,15] Constructors / Destructor and its Types
Muhammad Hammad Waseem
 
Java: Objects and Object References
Tareq Hasan
 
Object Oriended Programming with Java
Jakir Hossain
 
Unidad o informatica en ingles
Marisa Torrecillas
 

What's hot (19)

PPT
Object and Classes in Java
backdoor
 
PDF
Lect 1-java object-classes
Fajar Baskoro
 
PPTX
Class introduction in java
yugandhar vadlamudi
 
PPT
object oriented programming language by c++
Mohamad Al_hsan
 
PPT
Class and object in C++
rprajat007
 
PPTX
Constructors and destructors
Vineeta Garg
 
PPTX
Classes and objects
rajveer_Pannu
 
PDF
Class and object in C++ By Pawan Thakur
Govt. P.G. College Dharamshala
 
PPS
Introduction to class in java
kamal kotecha
 
PPTX
[OOP - Lec 20,21] Inheritance
Muhammad Hammad Waseem
 
PPS
Introduction to CSharp
Mody Farouk
 
PPT
Introduction to csharp
singhadarsh
 
PPT
Introduction To Csharp
g_hemanth17
 
PPT
Introduction to csharp
Raga Vahini
 
PPT
Classes & objects new
lykado0dles
 
PPTX
C#ppt
Sambasivarao Kurakula
 
PDF
How to write you first class in c++ object oriented programming
Syed Faizan Hassan
 
PPTX
Chapter2 array of objects
Mahmoud Alfarra
 
PPTX
Constructor & destructor
Saharsh Anand
 
Object and Classes in Java
backdoor
 
Lect 1-java object-classes
Fajar Baskoro
 
Class introduction in java
yugandhar vadlamudi
 
object oriented programming language by c++
Mohamad Al_hsan
 
Class and object in C++
rprajat007
 
Constructors and destructors
Vineeta Garg
 
Classes and objects
rajveer_Pannu
 
Class and object in C++ By Pawan Thakur
Govt. P.G. College Dharamshala
 
Introduction to class in java
kamal kotecha
 
[OOP - Lec 20,21] Inheritance
Muhammad Hammad Waseem
 
Introduction to CSharp
Mody Farouk
 
Introduction to csharp
singhadarsh
 
Introduction To Csharp
g_hemanth17
 
Introduction to csharp
Raga Vahini
 
Classes & objects new
lykado0dles
 
C#ppt
Sambasivarao Kurakula
 
How to write you first class in c++ object oriented programming
Syed Faizan Hassan
 
Chapter2 array of objects
Mahmoud Alfarra
 
Constructor & destructor
Saharsh Anand
 
Ad

Viewers also liked (12)

PDF
03 dp
Pankaj Prateek
 
PDF
05 graph
Pankaj Prateek
 
PDF
JavaScript, the good parts + syntactic sugar = CoffeeScript
geekQ
 
PDF
01 basics and stl
Pankaj Prateek
 
PPT
C++ Advanced
Vivek Das
 
ODP
Talk on Standard Template Library
Anirudh Raja
 
PDF
04 maths
Pankaj Prateek
 
PDF
Front End Development - Beyond Javascript (Robin Cannon)
Future Insights
 
PDF
Top 10 things a fresh programmer should know - Dao Ngoc Khanh
DevDay Da Nang
 
PDF
02 greedy, d&c, binary search
Pankaj Prateek
 
PDF
Security in the Internet of Things
ForgeRock
 
PDF
Becoming a Better Programmer
Pete Goodliffe
 
03 dp
Pankaj Prateek
 
05 graph
Pankaj Prateek
 
JavaScript, the good parts + syntactic sugar = CoffeeScript
geekQ
 
01 basics and stl
Pankaj Prateek
 
C++ Advanced
Vivek Das
 
Talk on Standard Template Library
Anirudh Raja
 
04 maths
Pankaj Prateek
 
Front End Development - Beyond Javascript (Robin Cannon)
Future Insights
 
Top 10 things a fresh programmer should know - Dao Ngoc Khanh
DevDay Da Nang
 
02 greedy, d&c, binary search
Pankaj Prateek
 
Security in the Internet of Things
ForgeRock
 
Becoming a Better Programmer
Pete Goodliffe
 
Ad

Similar to Advanced CPP Lecture 1- Summer School 2014 - ACA CSE IITK (20)

PPTX
CHAPTER -4-class and structure.pptx
GebruGetachew2
 
PPT
Data structure and problem solving ch01.ppt
Ping261512
 
PPT
2 lesson 2 object oriented programming in c++
Jeff TUYISHIME
 
PPTX
object oriented programming-classes and objects.pptx
RupaRaj6
 
PPT
Object and class presentation
nafisa rahman
 
PDF
2 BytesC++ course_2014_c5_ structures and classes
kinan keshkeh
 
PPTX
Pf cs102 programming-10 [structs]
Abdullah khawar
 
PPT
Oops lecture 1
rehan16091997
 
PPT
Savitch ch 10
Terry Yoast
 
PDF
C++ Notes
MOHAMED RIYAZUDEEN
 
PPT
Lecture number three Structures (1).ppt
shahbazqadeer1
 
PPT
Savitch Ch 10
Terry Yoast
 
PDF
Object Oriented Programming (OOP) using C++ - Lecture 1
Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt
 
PPTX
Classes and objects
Shailendra Veeru
 
PPT
CHAPTER-7 C++ PROGRAMMING ( STRUCTURE IN C++)
meharikiros2
 
PPTX
Structured Languages
Mufaddal Nullwala
 
PPTX
class c++
vinay chauhan
 
PPT
Structures
Praveen M Jigajinni
 
PPTX
Introduction to c ++ part -1
baabtra.com - No. 1 supplier of quality freshers
 
PPTX
Class and objects
nafisa rahman
 
CHAPTER -4-class and structure.pptx
GebruGetachew2
 
Data structure and problem solving ch01.ppt
Ping261512
 
2 lesson 2 object oriented programming in c++
Jeff TUYISHIME
 
object oriented programming-classes and objects.pptx
RupaRaj6
 
Object and class presentation
nafisa rahman
 
2 BytesC++ course_2014_c5_ structures and classes
kinan keshkeh
 
Pf cs102 programming-10 [structs]
Abdullah khawar
 
Oops lecture 1
rehan16091997
 
Savitch ch 10
Terry Yoast
 
C++ Notes
MOHAMED RIYAZUDEEN
 
Lecture number three Structures (1).ppt
shahbazqadeer1
 
Savitch Ch 10
Terry Yoast
 
Object Oriented Programming (OOP) using C++ - Lecture 1
Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt
 
Classes and objects
Shailendra Veeru
 
CHAPTER-7 C++ PROGRAMMING ( STRUCTURE IN C++)
meharikiros2
 
Structured Languages
Mufaddal Nullwala
 
class c++
vinay chauhan
 
Structures
Praveen M Jigajinni
 
Introduction to c ++ part -1
baabtra.com - No. 1 supplier of quality freshers
 
Class and objects
nafisa rahman
 

Recently uploaded (20)

PPTX
OOP with Java - Java Introduction (Basics)
Rashmi T V
 
PDF
keyrequirementskkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
mojeeburahmanwardak
 
PDF
PRIZ Academy - 9 Windows Thinking Where to Invest Today to Win Tomorrow.pdf
PRIZ Guru
 
PPTX
Construction Project Organization Group 2.pptx
vj5agdales
 
PDF
PPT on Performance Review to get promotions
prashant593122
 
PDF
BMEC211 - INTRODUCTION TO MECHATRONICS-1.pdf
ryankakungu
 
PPTX
Internet of Things (IOT) - A guide to understanding
Davies Chacko
 
PPTX
Engineering Ethics, Safety and Environment [Autosaved] (1).pptx
MehrabTaseenTalukder
 
PPTX
FINAL REVIEW FOR COPD DIANOSIS FOR PULMONARY DISEASE.pptx
rubeshbme
 
PDF
Embodied AI: Ushering in the Next Era of Intelligent Systems
Yu Huang
 
PPTX
Foundation to blockchain - A guide to Blockchain Tech
Davies Chacko
 
PDF
SM_6th-Sem__Cse_Internet-of-Things.pdf IOT
smceramu
 
PPTX
web development for engineering and engineering
keshriji700
 
PDF
Digital Logic Computer Design lecture notes
CHINNASUNKAIAH1
 
PPTX
Welding lecture in detail for understanding
sahilpoonia10
 
PPT
CRASH COURSE IN ALTERNATIVE PLUMBING CLASS
rene militante
 
PPTX
Lecture Notes Electrical Wiring System Components
eedgecbhojpur
 
PPTX
bas. eng. economics group 4 presentation 1.pptx
kiribakimoses1993
 
PDF
Well-logging-methods_new................
ZafriFarid
 
PPTX
additive manufacturing of ss316l using mig welding
premcdr7799
 
OOP with Java - Java Introduction (Basics)
Rashmi T V
 
keyrequirementskkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
mojeeburahmanwardak
 
PRIZ Academy - 9 Windows Thinking Where to Invest Today to Win Tomorrow.pdf
PRIZ Guru
 
Construction Project Organization Group 2.pptx
vj5agdales
 
PPT on Performance Review to get promotions
prashant593122
 
BMEC211 - INTRODUCTION TO MECHATRONICS-1.pdf
ryankakungu
 
Internet of Things (IOT) - A guide to understanding
Davies Chacko
 
Engineering Ethics, Safety and Environment [Autosaved] (1).pptx
MehrabTaseenTalukder
 
FINAL REVIEW FOR COPD DIANOSIS FOR PULMONARY DISEASE.pptx
rubeshbme
 
Embodied AI: Ushering in the Next Era of Intelligent Systems
Yu Huang
 
Foundation to blockchain - A guide to Blockchain Tech
Davies Chacko
 
SM_6th-Sem__Cse_Internet-of-Things.pdf IOT
smceramu
 
web development for engineering and engineering
keshriji700
 
Digital Logic Computer Design lecture notes
CHINNASUNKAIAH1
 
Welding lecture in detail for understanding
sahilpoonia10
 
CRASH COURSE IN ALTERNATIVE PLUMBING CLASS
rene militante
 
Lecture Notes Electrical Wiring System Components
eedgecbhojpur
 
bas. eng. economics group 4 presentation 1.pptx
kiribakimoses1993
 
Well-logging-methods_new................
ZafriFarid
 
additive manufacturing of ss316l using mig welding
premcdr7799
 

Advanced CPP Lecture 1- Summer School 2014 - ACA CSE IITK

  • 1. ACA Summer School 2014 Advanced C++ Pankaj Prateek ACA, CSE, IIT Kanpur June 23, 2014
  • 2. Course website: http: //www.cse.iitk.ac.in/users/aca/sumschool2014.html Evaluation End Sem - 50% Assignments / In-class quiz - 50% Timings: M-F 1430 - 1600 hrs
  • 3. Prerequisites A good command over any programming language preferably C/C++ Pointers Structures
  • 4. Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
  • 5. Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
  • 6. Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
  • 7. Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
  • 8. Structures How do you store the details of a person? char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; Information is not grouped in any way. To pass your information to a function, you would have to pass each variable independently. If wanted to store information about many people, would have to declare arrays.
  • 9. Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
  • 10. Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
  • 11. Structures C++ allows to create own user-defined data types to aggregate different variables : structs Structure declaration struct Person{ char strName [20]; int nBirthYear; int nBirthMonth; int nBirthDay; int nHeight; }; //DO NOT forget a semicolon Now person structure can be used as a built-in variable.
  • 12. Structures Usage struct Person p1; struct Person p2; Accessing Members: p1.name = ‘‘pankaj ’’; p1.nBirthDay = 20; p2.name = ‘‘Rahul ’’;
  • 13. Structures Usage struct Person p1; struct Person p2; Accessing Members: p1.name = ‘‘pankaj ’’; p1.nBirthDay = 20; p2.name = ‘‘Rahul ’’;
  • 14. Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
  • 15. Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
  • 16. Structures No memory is allocated in structure declaration Size of a structure is the sum of sizes of it elements Can pass entire structures to functions void PrintInfo(struct Person p) { cout << ‘‘Name: ’’ << p.name <<endl; cout << ‘‘bDay: ’’ << p.nBirthDay <<endl; } int main () { struct Person p1; p1.name = ‘‘Pankaj ’’; p1.nBirthDay = 20; PrintInfo(p1); }
  • 17. Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
  • 18. Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
  • 19. Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
  • 20. Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
  • 21. Structures Always have to use the word “struct” No explicit connection between members of a structure and the functions manipulating them Cannot be treated as built-in types (c1 + c2 is not valid for instances of “struct complex”) Data hiding is not permitted (Why do we need this?) All members of a structure are by defaut “public” (will be discussed later)
  • 22. Classes Extension of structures Class Definition class class_name { private: variable declarations; function declarations; public: variable declarations; function declarations; }; //DO NOT forget the semicolon
  • 23. Classes Extension of structures Class Definition class class_name { private: variable declarations; function declarations; public: variable declarations; function declarations; }; //DO NOT forget the semicolon
  • 24. Class: Example Example class item { private: int number; // variable declarations float cost; // private by default! public: // function declarations through prototypes void getData(int a, float b); void putData(void ); }
  • 25. Class No memory allocated for a class definiton. It is only a “template”, like a definition of a structure
  • 26. Class: Public and Private Private members are not directly accessible outside the class. They are “hidden” from the outside world. The only way to access them is by using public functions (if defined) which manipulate them. Public members can be accessed using the dot operator (member selection operator). Eg. student.name, item.getData()
  • 27. Class: Public and Private Private members are not directly accessible outside the class. They are “hidden” from the outside world. The only way to access them is by using public functions (if defined) which manipulate them. Public members can be accessed using the dot operator (member selection operator). Eg. student.name, item.getData()
  • 28. Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
  • 29. Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
  • 30. Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
  • 31. Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
  • 32. Class: Objects Class, like a structure definition, is a user-defined data type without any concrete existance. A concrete instance of a class is an object. Memory is allocated for every object that is created. An independent new set of variables is created for each object. Public members can be accessed by using the dot operator on the object while private members cannot be accessed directly.
  • 33. Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
  • 34. Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
  • 35. Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
  • 36. Class: Objects Object Creation Just like variable declaration Memory is allocated for every object that is created Example: item a; item b,c,d;
  • 37. Class: Function definitions Outside the class class Employee { int empno , salary; public: void set(int roll , int sal); }; void employee ::set(int roll , int sal) { empno = roll; salary = sal; }
  • 38. Class: Function definitions Outside the class class Employee { int empno , salary; public: void set(int roll , int sal); }; void employee ::set(int roll , int sal) { empno = roll; salary = sal; }
  • 39. Class: Function definitions Inside the class class Employee { int empno , salary; public: void set(int roll , int sal) { empno = roll; salary = sal; } };
  • 40. Class: Function definitions Inside the class class Employee { int empno , salary; public: void set(int roll , int sal) { empno = roll; salary = sal; } };
  • 41. Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
  • 42. Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
  • 43. Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
  • 44. Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
  • 45. Important Properties Invoking other member functions from inside a member function does not require explicit use of the object Array size, if used inside classes, need to be determined at compile time (for dynamic arrays, with size to be determined at run time, “new” operator is used inside a constructor, will be discussed later) Arrays of objects are allowed (stored contiguously). Objects can be used as members of some other class in nested fashion. Objects, just like built-in types, can be return type of functions. Private functions and variables can only be accessed from within the class.
  • 46. Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
  • 47. Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
  • 48. Classes Problem Consider a class “car” which has the carNo, carModel, carMake fields and relevant functions to modify them. You have to count the number of objects of the class created. How do you do it?
  • 49. Static Members class item { static int count; // rest of class definition }; int item :: count;
  • 50. Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
  • 51. Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
  • 52. Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
  • 53. Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
  • 54. Static Members Properties Every static member needs to be defined outside the class as well. Only one copy of the static variable is shared among all objects of the class. Visible only within the class but exists for the lifetime of the program. No object instantiation is required to access static members.
  • 55. Memory Allocation of Objects For member functions and static variables, memory is allocated when the class is defined, all objects of the class share the same function code and static variables (every class does not get its own copy). “this” pointer is implicitly passed so that the function code is executed on the correct class instance. For variables, memory is allocated when the object is defined. Each instance gets its own set of variables.
  • 56. Memory Allocation of Objects For member functions and static variables, memory is allocated when the class is defined, all objects of the class share the same function code and static variables (every class does not get its own copy). “this” pointer is implicitly passed so that the function code is executed on the correct class instance. For variables, memory is allocated when the object is defined. Each instance gets its own set of variables.
  • 57. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 58. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 59. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 60. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 61. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 62. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 63. Class: Friend Shared functions among multiple classes Properties: Can access private members of the class Often used in operator overloading Not in the scope of the class. Cannot be called using an object of the class. Can be invoked like a normal function Cannot access members of a class directly without an object of the class
  • 64. Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
  • 65. Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
  • 66. Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
  • 67. Class: Friend Properties: (cont. . . ) Can be declared as either private or public without changing the meaning Objects can be passed to the function by value or by reference A class can be defined to be the friend of another class. In that case, all member functions of one class are friends of the other class
  • 68. References The C++ Programming Language - Bjarne Stroustrup Object Oriented Programming with C++ - E Balaguruswamy http://www.cplusplus.com/reference http://www.learncpp.com/ http://www.java2s.com/Code/Cpp/CatalogCpp.htm