1. Array in C++ / review

2. An array contains multiple objects of identical types stored sequentially in memory. The individual objects in an array, referred to as array elements, can be addressed using a number, called index or subscript. The array is the most commonly used data storage structure. It helps us to see how object-oriented programming and data structures relate to each other.

3. Like a regular variable, an array must be declared before it is used. A typical declaration for an array in C++ is: type name [ no of elements]; You can create an array from any type with the exception of some special types. An array always occupies a contiguous memory space. To know how much memory spaces an array needs, for example, if we have an array of 10 elements, this space is 10*sizeof(float) = 40 bytes.

4. when declaring an array, there is a possibility to assign initial values to each one of its elements. To access the values of an array; being able to both read and modify its value by using this format : name[index]

5. # include using namespace std; int main() { int n[10]; for( int i=0;i<10;i++) n[i] =0; cout<<“Element”<<setw(13)<<“value”<<endl; for(int j=0; j<10;j++) cout<<setw(7)<<j<<setw(13)<<n[j]<<endl; return 0; }

6.  How to assign initial values to a char array : char name[ ] = “welcome back"; This definition is equivalent to char name[ ] = {‘w’, ‘e’, ‘l’, ‘c’, ‘o’, ‘m’, ‘e’, ‘ ‘, ‘b’, ‘a’, ‘c’, ‘k’, ‘\0’};

7. Multidimensional arrays can be described as "arrays of arrays". Multidimensional arrays are not limited to two indices. #define WIDTH 3 #define HEIGHT 2 int table [HEIGHT][WIDTH]; int n,m; int main () { for (n=0;n<HEIGHT; n++) for (m=0; m<WIDTH; m++) { table [n][m]=(n+1)*(m+1); } return 0; }

8. Array Advantages: Easier to declare and use. Can be used with most of the data types. Array Disadvantages: Fixed size data. Ex: if the number of elements to be stored are more than the maximum size, the array cannot accommodate those new values.

9. Any Question? Refer to chapter 1 of the book for further reading

10. Review Function

11. FUNCTIONS If you are looking to provide a solution for a more complex problem, it will help to divide the problem into smaller units. Functions can be defined in any order, however, the first function is normally main. Definition syntax: type name ( parameter1, parameter2,...) { statements }

13. Prototype and Definition In a function definition, the function header is similar in form to the prototype(declaration) of a function. State the differences between the prototype and function declaration? When do the function must be declare? The prototype provides the compiler with all the information it needs when a function is called, what are these information and what will happen after that? Can the function declaration be omitted ? When ?

14. ■ RETURN VALUE OF FUNCTIONS When a function is called, an argument of the same type as the parameter must be passed to the function for each parameter. Note: the arguments can be also any kind of expressions. If the function is any type other than void, the return statement will cause the function to return a value to the function that called it. When the program flow reaches a return statement or the end of a function code block, where it goes?

15. ■ PASSING ARGUMENTS Passing values to a function when the function is called is referred to as passing by value, does it access the object it self directly? However, function arguments can also be passed by reference.

17. 17

19. Other topics to review Overloading function. Inline function. Recursion. Default arguments.

20. Any Question? Refer to chapter 1 of the book for further reading

21. 21 Pointers

22. Each cell can be easily located in the memory because it has a unique address. Reference operator (&) The address that locates a variable within memory is what we call a reference to that variable. This reference can be obtained by preceding the identifier of a variable with an ampersand sign (&), known as reference operator. Note that using the address/refrence operator, &, for a given object creates a pointer to that object. Example: given that var is an int variable, &var is address of the object var

23. Dereference operator (*) A variable which stores a reference to another variable is called a pointer. Using a pointer we can directly access the value stored in the variable which it points to. To do that, precede the pointer's identifier with an asterisk (*), which acts as dereference operator and that can be translated to "value pointed by".

24. Pointer variable - declaration and initialization A pointer is an expression that represents both the address and type of another object. Any pointer is placed during runtime in the specific memory address. An expression such as &var is a constant pointer; however, C++ allows you to define pointer variables, that is, variables that can store the address of another object. In a declaration, the star character * always means “pointer to.” Example: int *ptr; Pointer variables contain memory addresses as their values.

25. After declaring a pointer variable, you must point the pointer at a memory address by using the address operator. Example : int y = 5; // declare variable y int *yPtr; // declare pointer variable yPtr the statement yPtr = &y; // initialize-assign address of y to yPtr

26. 26

27. 27

28. Indirection operator The indirection operator(dereference operator) * is used to access an object referenced by a pointer: Given a pointer, ptr, *ptr is the object referenced by ptr. Example: long a = 10, b, *ptr; ptr = &a; // Let ptr point to a. b = *ptr; Note : The indirection operator * has high precedence, just like the address operator &. Both operators are unary.

29. 29

30. References

31. DEFINING REFERENCES 31 A reference is another name, or alias, for an object that already exists. Defining a reference does not occupy additional memory. Any operations defined for the reference are performed with the object to which it refers.

32. 32 The ampersand character, &, is used to define a reference. Given that T is a type, T& denotes a reference to T. Example: float x = 10.7; float& rx = x; //The place contents the value 10.7. have two names and one address. cout<<x<< endl;//output: 10.7 cout<<&x<<endl;//address of x in memory cout<<rx<< endl;// output: 10.7 cout<<&rx<< endl;//address of x in memory = &x

33. Any Question? Refer to chapter 1 of the book for further reading

34. In C++ Classes

35. What is a class Can make a new type in C++ by declaring a class. A class is an expanded concept of a data structure: instead of holding only data, it can hold both data and functions. It is just a collection of variables with a set of related functions. The variables in the class are referred to as the member variables or data members. The functions in the class manipulate the member variables. They are referred to as member functions or methods of the class.

36. An object is an instantiation of a class. In terms of variables, a class would be the type, and an object would be the variable. A class enables you to encapsulate these variables and functions into one collection, which is called an object. Declaring a Class To declare a class, use the class keyword followed by a class name and an opening brace, then list the data members and methods of that class. End the declaration with a closing brace and a semicolon.

37. Example: class Part { int modelnumber; double cost; void SetPart(int mn, double c); void ShowPart(); }; Note : You cannot initialize data members where you declare them. A method declaration can also include the implementation, or you can implement it separately). All methods can be accessed only through an object of the class.

38. Defining an object An object is an individual instance of a class. To define an object of a new type just as defining an integer variable (or any other variable): Part wheel; This code defines wheel, which is an object whose class (or type) is Part.

39. Calling Data Member and methods Once you define an actual Part object, for example, wheel you use the dot operator (.) to access the members of that object. Therefore, to assign 50 to wheel’s modelnumber member variable wheel.modelnumber = 50; In the same way, to call the ShowPart() function, wheel.ShowPart(); //method calling

40. Assign Values to Objects, Not to Classes In C++ you don't assign values to types; you assign values to variables. For example, int x = 50;//define x to be an int int = 50; // wrong In the same way, Part.modelnumber = 50; //wrong you must define a Part object and assign 50 to the modelnumber of that object. Part wheel; //just like int x; wheel.modelnumber = 50; //just like x = 50;

41. Using Access Specifiers C++ allows to control where the data members of a class can be accessed to protect them. An access specifier is a word that controls where the data members in a class can be accessed. An access specifier affects all members of the class that come after it until another access specifier is encountered or until you reach the end of the class. class ClassName { classMembers; accessSpecifier: classMembers;};

42. A class has two kinds of access specifiers: public and private. public members can be accessed anywhere that an object of the class can be accessed and from within the class (that is, in the class’s methods). private members can be accessed only from within the class itself. Note: an object of the class cannot access the private members, except through public methods. If no access specifier is provided in the class, all members default to private.

43. Example class Part { public: int modelnumber; double cost; void SetPart(int m, double c); void ShowPart(); }; Now wheel.modelnumber = 50; compiles without problems.

44. Private and Public Data Usually the data within a class is private and the functions are public. However, there is no rule for that.

46. Memory Allocation Declaring this class doesn't allocate memory for a Part. It just tells the compiler what a Part is, what data it contains, and what it can do. It also tells the compiler how big a Part is (that is, how much room the compiler set for each Part (objects) that you create).

47. Creating Methods You can declare a method two ways. 1. The most common way is to declare a method inside the class declaration and then implement it outside. 2. The second way is to declare and implement the method at the same time inside the class declaration. However, there is special syntax for the method definition. A member function definition begins with the return type, followed by the name of the class, two colons (::), the name of the function, and its parameters.

48. The general syntax for a method implementation that occurs outside a class: return_type ClassName::methodName(parameterList) { method implementation; } The double colon (::) is called the scope resolution operator.

49. Constructor and Destructor These are special kinds of methods that can be in a class, and they are optional They provide special functionality that other methods cannot provide. A constructor is executed every time you declare a new object. It is normally used to set initial values for the data members. always has the same name as the class and cannot have a return value (not even void).

50. A destructor is the opposite of a constructor and is executed when the object is destroyed. It is always named the same name as the class, but with a tilde (~) at the beginning. It cannot have arguments or a return value. A destructor is often used to perform any necessary cleanup tasks.

51. Both constructors and destructors are like methods; they can be declared and implemented at the same time or declared and implemented separately. The syntax for declaring and implementing at the same time: class ClassName {//constructor ClassName(argumentList) {implementation;} //destructor ~ClassName() {implementation;} //other members };

52. Here is the syntax for declaring and then implementing: class ClassName { ClassName(argumentList); ~ClassName(); //other Member; }; ClassName::ClassName([argumentList]) {implementation;} ClassName::~ClassName() {implementation;}

53. Notice : the constructor can have arguments. If you create a constructor with arguments, the user of the class must supply values for these arguments when creating an object. Notice : the destructor cannot have arguments. It is called automatically, so no chance for the user to provide arguments. Because a constructor can have arguments, it might become necessary to overload the constructor. This is legal in C++ and is quite common in large classes. Overloading the constructor in this way gives your class versatility and provides users of the class with many options. The destructor cannot be overloaded since there is no return type or arguments.

61. Separating Classes into Files What are the benefit of separating classes in to files ? Normally, to do the separation, the class declaration is placed in one file (header file), and the implementation of all the methods is put in another file. The class declaration file is normally called ClassName.h. The implementation file is normally called ClassName.cpp. Then you include the header file in your program with an #include directive.

62. However, instead of including two files (ClassName.h and ClassName.cpp), you have to include only ClassName.h. The compiler will include the.cpp file automatically Don’t forget: the two files need to be in the same directory to achieve that).

65. Pointers To Objects An object of a class has a memory address. You can assign this address to a suitable pointer. For example Part part1(320); Part * partPtr = &part1; Now we can use the pointer like : (*partPtr).setPart();

66. Arrow Operator You can use the class member access operator -> (arrow operator) instead of a combination of (*) and (.). Syntax: objectPointer->member This expression is equivalent to (*objectPointer).member The difference between the class member access operators (.) and (->) is that the left operand of the dot operator must be an object, whereas the left operand of the arrow operator must be a pointer to an object.

67. Any Question? Refer to chapter 1 of the book for further reading