Array and Functions (Lecture 8th)

C++ Arrays

Arrays are used to store multiple values in a single variable, instead of declaring
separate variables for each value.

To declare an array, define the variable type, specify the name of the array
followed by square brackets and specify the number of elements it should store:

int myNum[3] = {10, 20, 30};

Omit Array Size

In C++, you don't have to specify the size of the array. The compiler is smart
enough to determine the size of the array based on the number of inserted values:

int myNum[] = {10, 20, 30}; // Three arrays

The example above is equal to:

int myNum[3] = {10, 20, 30}; // Also three arrays

Access the Elements of an Array

You access an array element by referring to the index number inside square
brackets [].

This statement accesses the value of the first element in myNum;

Cout<<myNum[1]<<endl; //20

Access the Elements of an Array by loop

You access an array element by referring to the index number inside square
brackets [].
Using loop;;;;;;

The size of int[] is basically cuounting the number of elements inside that array. To get this we can use
the sizeof() operator. If the array name is passed inside the sizeof(), then it will return total size of
memory blocks that are occupied by the array. Now if we divide it by the size of each element, then we
can get number of elements.

1. To find out the size of an array in C++ we can use multiple techniques. Using sizeof
Operator to find Size of Array in C++.
2. Using pointer to calculate size of array. (will cover after studying pointers)

3. Using end () and begin () functions. Using std::array container size () function.

1-

int data[] = { 11, 22, 33, 44, 55, 66, 77, 88, 99, 91, 82, 73, 64 };
cout << "Memory occupied by data[]: " << sizeof(data) << endl;
cout << "Size of data[] array: " << sizeof(data) / sizeof(data[0]) <<
endl;

or you can write

int myNumbers[5] = {10, 20, 30, 40, 50};
int getArrayLength = sizeof(myNumbers) / sizeof(int);
cout << getArrayLength;

The function len () is one of Python ’ s built −¿ functions . It returns the length of an object. For
example, it can return the number of items in a list.

Array with Function

#include<iostream>
using namespace std;
void showArray(int[]);
int len = 0;
int main()
{

int data[] = { 11, 22, 33, 44, 55, 66, 77, 88, 99, 91, 82, 73, 64 };
cout << "Memory occupied by data[]: " << sizeof(data) <<endl;
cout << "Size of data[] array: " << sizeof(data) / sizeof(data[0]) <<
endl;
len = sizeof(data) / sizeof(data[0]);
showArray(data);

system("pause");

}//end of main

void showArray(int d[13])

{
for (int i = 0; i < len;i++)
{
cout << "array Data[]" << d[i] << endl;
}
}

another method
int myNumbers[5] = {10, 20, 30, 40, 50};
for (int i = 0; i < sizeof(myNumbers) / sizeof(int); i++) {
  cout << myNumbers[i] << "\n";
}

C++ provides following two types of string representations −

 The C-style character string.

 The string class type introduced with Standard C++.

The C-Style Character String

The C-style character string originated within the C language and continues to be supported
within C++. This string is actually a one-dimensional array of characters which is terminated by
a null character '\0'. Thus a null-terminated string contains the characters that comprise the string
followed by a null.
The following declaration and initialization create a string consisting of the word "Hello". To
hold the null character at the end of the array, the size of the character array containing the string
is one more than the number of characters in the word "Hello."
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
If you follow the rule of array initialization, then you can write the above statement as follows −
char greeting[] = "Hello";
Following is the memory presentation of above defined string in C/C++ −

Actually, you do not place the null character at the end of a string constant. The C++ compiler
automatically places the '\0' at the end of the string when it initializes the array. Let us try to print
above-mentioned string –

#include <iostream>

using namespace std;

int main () {

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

cout << "Greeting message: ";

cout << greeting << endl;

return 0;
}

Sr.No Function & Purpose

1
strcpy(s1, s2);
Copies string s2 into string s1.

2
strcat(s1, s2);
Concatenates string s2 onto the end of string s1.
 3
strlen(s1);
Returns the length of string s1.

4
strcmp(s1, s2);
Returns 0 if s1 and s2 are the same; less than 0 if s1<s2; greater than 0 if s1>s2.

5
strchr(s1, ch);
Returns a pointer to the first occurrence of character ch in string s1.

6
strstr(s1, s2);
Returns a pointer to the first occurrence of string s2 in string s1.

string str1 = "Hello";

string str2 = "World";
string str3;
int len ;

// copy str1 into str3

str3 = str1;
cout << "str3 : " << str3 << endl;

// concatenates str1 and str2

str3 = str1 + str2;
cout << "str1 + str2 : " << str3 << endl;

// total length of str3 after concatenation

len = str3.size();
cout << "str3.size() : " << len << endl;

Learning:

Do not use string.h in visual studio

Use only string

Pointers
C++ pointers are easy and fun to learn. Some C++ tasks are performed more easily with pointers,
and other C++ tasks, such as dynamic memory allocation, cannot be performed without them.
As you know every variable is a memory location and every memory location has its address
defined which can be accessed using ampersand (&) operator which denotes an address in
memory. Consider the following which will print the address of the variables defined –
#include <iostream>

using namespace std;

int main () {
int var1;
char var2[10];

cout << "Address of var1 variable: ";

cout << &var1 << endl;

cout << "Address of var2 variable: ";

cout << &var2 << endl;

return 0;
}

When the above code is compiled and executed, it produces the following result −
Address of var1 variable: 0xbfebd5c0 //it may differ
Address of var2 variable: 0xbfebd5b6 //it may differ

What are Pointers?

A pointer is a variable whose value is the address of another variable. Like any variable or
constant, you must declare a pointer before you can work with it. The general form of a pointer
variable declaration is −
type *var-name;
Here, type is the pointer's base type; it must be a valid C++ type and var-name is the name of
the pointer variable. The asterisk you used to declare a pointer is the same asterisk that you use
for multiplication. However, in this statement the asterisk is being used to designate a variable as
a pointer. Following are the valid pointer declaration −
int *ip; // pointer to an integer //4bytes
double *dp; // pointer to a double//4bytes

float *fp; // pointer to a float//4bytes

char *ch // pointer to character//4bytes

The actual data type of the value of all pointers, whether integer, float, character, or otherwise, is
the same, a long hexadecimal number that represents a memory address. The only difference
between pointers of different data types is the data type of the variable or constant that the
pointer points to.

Note

Why size of all pointer is same?

Using Pointers in C++

There are few important operations, which we will do with the pointers very frequently. 
(a) We define a pointer variable. 
(b) Assign the address of a variable to a pointer. 
(c) Finally access the value at the address available in the pointer variable. This is done by using
unary operator * that returns the value of the variable located at the address specified by its
operand.
Following example makes use of these operations −
#include <iostream>

using namespace std;

int main () {
int var = 20; // actual variable declaration.
int *ip; // pointer variable

ip = &var; // store address of var in pointer variable

cout << "Value of var variable: ";

cout << var << endl;

// print the address stored in ip pointer variable

cout << "Address stored in ip variable: ";
cout << ip << endl;
 // access the value at the address available in pointer
cout << "Value of *ip variable: ";
cout << *ip << endl;

return 0;
}

When the above code is compiled and executed, it produces result something as follows −
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac//it may differ
Value of *ip variable: 20

Pointers in C++
Pointers have many but easy concepts and they are very important to C++ programming. There
are following few important pointer concepts which should be clear to a C++ programmer −

Sr.No Concept & Description

1 Null Pointers
C++ supports null pointer, which is a constant with a value of zero defined in several standard
libraries.

2 Pointer Arithmetic
There are four arithmetic operators that can be used on pointers: ++, --, +, -

3 Pointers vs Arrays
There is a close relationship between pointers and arrays.

4 Array of Pointers
You can define arrays to hold a number of pointers.

5 Pointer to Pointer
C++ allows you to have pointer on a pointer and so on.

6 Passing Pointers to Functions

Passing an argument by reference or by address both enable the passed argument to be changed in
 the calling function by the called function.

7 Return Pointer from Functions

C++ allows a function to return a pointer to local variable, static variable and dynamically
allocated memory as well.

5- Pointer to Pointer

A pointer to a pointer is a form of multiple indirection or a chain of pointers. Normally, a pointer

contains the address of a variable. When we define a pointer to a pointer, the first pointer
contains the address of the second pointer, which points to the location that contains the actual
value as shown below.

A variable that is a pointer to a pointer must be declared as such. This is done by placing an
additional asterisk in front of its name. For example, following is the declaration to declare a
pointer to a pointer of type int −
int **var;
When a target value is indirectly pointed to by a pointer to a pointer, accessing that value
requires that the asterisk operator be applied twice, as is shown below in the example −
#include <iostream>

using namespace std;

int main () {
int var;
int *ptr;
int **pptr;

var = 3000;

// take the address of var

ptr = &var;

// take the address of ptr using address of operator &

pptr = &ptr;

// take the value using pptr

 cout << "Value of var :" << var << endl;
cout << "Value available at *ptr :" << *ptr << endl;
cout << "Value available at **pptr :" << **pptr << endl;

return 0;
}
When the above code is compiled and executed, it produces the following result −
Value of var :3000
Value available at *ptr :3000
Value available at **pptr :3000

Learning:

Note that when

pptr = &ptr;

when pointer is assigned to pointer to pointer (do not use word double pointer)

6- Passing Pointers to Functions

Passing an argument by reference or by address both enable the passed argument to be changed
in the calling function by the called function.
C++ allows you to pass a pointer to a function. To do so, simply declare the function parameter
as a pointer type.
Following a simple example where we pass an unsigned long pointer to a function and change
the value inside the function which reflects back in the calling function −
#include <iostream>
#include <ctime>

using namespace std;

void getSeconds(unsigned long *par);

int main () {
unsigned long sec;
getSeconds( &sec );

// print the actual value

cout << "Number of seconds :" << sec << endl;

return 0;
}
void getSeconds(unsigned long *par) {
// get the current number of seconds
*par = time( NULL );

return;
}

The function which can accept a pointer, can also accept an array as shown in the following example –

#include <iostream>
using namespace std;

// function declaration:
double getAverage(int *arr, int size);

int main () {
// an int array with 5 elements.
int balance[5] = {1000, 2, 3, 17, 50};
double avg;

// pass pointer to the array as an argument.

avg = getAverage( balance, 5 ) ;

// output the returned value

cout << "Average value is: " << avg << endl;

return 0;
}

double getAverage(int *arr, int size) {

int i, sum = 0;
double avg;

for (i = 0; i < size; ++i) {

sum += arr[i];
}
avg = double(sum) / size;

return avg;
}
When the above code is compiled together and executed, it produces the following result −
Average value is: 214.4
7-Return Pointer from Functions in C++
C++ allows a function to return a pointer to local variable, static variable and dynamically allocated
memory as well.
As we have seen in last chapter how C++ allows to return an array from a function, similar way C++
allows you to return a pointer from a function. To do so, you would have to declare a function returning a
pointer as in the following example –

int * myFunction() {
.
.
.
}
Second point to remember is that, it is not good idea to return the address of a local variable to
outside of the function, so you would have to define the local variable as static variable.
Now, consider the following function, which will generate 10 random numbers and return them
using an array name which represents a pointer i.e., address of first array element.

Simple example
int * getArray(int [],int); ////Return Pointer from
Functions in C++
main()

int x[3] = {22,33,45};

int size = 3;
int *ptr = getArray(x,size);
for (int i = 0; i < size;i++)
{

cout << "Address of"<<i<<" index: " << &ptr[i] << "
Value at " << i << "index" << *ptr << endl;
ptr++;
}
}

//Return Pointer from Functions in C++

int * getArray(int y[3], int sizearr)
{

return y;

Return array from functions

C++ allows a function to return an array.
C++ does not allow to return an entire array as an argument to a function. However, you can
return a pointer to an array by specifying the array's name without an index.
If you want to return a single-dimension array from a function, you would have to declare a
function returning a pointer as in the following example −
int * myFunction() {
.
.
.
}
Second point to remember is that C++ does not advocate to return the address of a local variable
to outside of the function so you would have to define the local variable as static variable.

Repeat the code of “7-Return Pointer from

Functions in C++”