C++

Question 1

Difference b/w \n and endl

Answer 1

\n - Just puts a newline

endl - Will also flush the buffer

Question 2

What happens when two operators of equal precedence occur in an expression?

Answer 2

The Associativity will apply from left to right.

Question 3

What is a Comma(,) operator in C++?

Answer 3

In C and C++, comma (, ) can be used in two contexts:
1) Comma as an operator:
The comma operator (represented by the token, ) is a binary operator that evaluates its first operand and discards the result, it then evaluates the second operand and returns this value (and type). The comma operator has the lowest precedence of any C operator and acts as a sequence point.

/* comma as an operator */
int i = (5, 10); /* 10 is assigned to i*/
int j = (f1(), f2()); /* f1() is called (evaluated) first followed by f2().
The returned value of f2() is assigned to j */

2) Comma as a separator:
Comma acts as a separator when used with function calls and definitions, function-like macros, variable declarations, enum declarations, and similar constructs.

/\* comma as a separator \*/
int a = 1, b = 2;
void fun(x, y);

More info: Comma Operator

Question 4

What is the output of following program? 

#include 

using namespace std;

int main()
{
~~~

int a = 5;
a = 2, 3, 4;
cout << a;
return 0; } ~~~

Answer 4

Output: 2

The following expression in the code:

a = 2, 3, 4;

is evaluated as:

(((a = 2), 3), 4);

This is because the reason that assignment operator has high precedence over the comma operator.

Question 5

What is the output?

#include
using namespace std;
~~~

int main()
{
    int arr[2] = {10, 20, 30};

return 0; } ~~~

Answer 5

Compile error:

prog.cpp: In function ‘int main()’: prog.cpp:6:29: error: too many initializers for ‘int [2]’ int arr[2] = {10, 20, 30}; ^

Question 6

What is the output?

#include
using namespace std;
~~~

int main()
{
    int arr[2] = {10, 20};

cout << arr[0] << " " << arr[1] << " " << arr[2];

return 0; } ~~~

Answer 6

10 20 1294526976

If trying to access the array out of bound(arr[2]), it prints a random value.

Question 7

What is the output?

#include
using namespace std;
~~~

int main()
{
    int arr1[2] {10, 20};
    int arr2[6] {10, 20};

cout << arr1[0] << " " << arr1[1] << " ";

cout << arr2[0] << " " << arr2[1] << " " << arr2[2];

return 0; } ~~~

Answer 7

10 20 10 20 0

When Array is partially initialized, it stores 0 values in the non-initialized values.

Question 8

What is the output? 

#include
using namespace std;
~~~

int main()
{
    int arr[] = {10, 20, 30, 40};

cout << sizeof(arr);

return 0; } ~~~

Answer 8

16

Size of 4 int elements

Question 9

What is the output?

#include
using namespace std;
~~~

int main()
{
    int arr[] = {10, 20, 30, 40};

cout << sizeof(arr)/sizeof(arr[0]);

return 0; } ~~~

Answer 9

4

Size of 4 int elements = 16 / Size of single int element

Question 10

Output?

#include < iostream >
using namespace std;
~~~

int main()
{
char str[] = “gfg”;
cout &laquo_space;str;
return 0;
}
~~~

Answer 10

O/p: gfg

This is a C-style string with a null termination at the end. It stores as “gfg\0”.

Question 11

Output?

#include < iostream >
using namespace std;
~~~

int main()
{
    char str[] = "gfg";
    cout << sizeof(str);
    return 0;
}

~~~

Answer 11

O/p: 4

C-style strings include the null character also in the size.

Question 12

Output? 

#include < iostream >
using namespace std;
~~~

int main()
{
    char str[3] = "gfg";
    cout << sizeof(str);
    return 0;
}

~~~

Answer 12

Compile error:

prog.cpp: In function ‘int main()’: prog.cpp:6:19: error: initializer-string for array of chars is too long [-fpermissive] char str[3] = “gfg”; ^

Question 13

Output?

#include < iostream >
using namespace std;
~~~

int main()
{
char str[] = {‘g’, ‘f’, ‘g’};
cout &laquo_space;str;
return 0;
}
~~~

Answer 13

O/p: gfg¸ü

Some random characters at the end

Question 14

#include
using namespace std;

int main()
{
char str[] = {‘g’, ‘f’, ‘g’, ‘\0’};
cout &laquo_space;str &laquo_space;endl;
cout &laquo_space;sizeof(str) &laquo_space;endl;
return 0;
}
~~~

~~~

Answer 14

O/p:

gfg

4

Question 15

Output?

#include < iostream >
#include < cstring >
using namespace std;
~~~

int main()
{
char s1[] = “abc”;
char s2[] = “bcd”;
int res = strcmp(s1, s2);
if (res > 0)
cout &laquo_space;“Greater”;
else if(res == 0)
cout &laquo_space;“Same”;
else
cout &laquo_space;“Smaller”;
}
~~~

Answer 15

O/p: Smaller

strcmp compares the string lexicographically, i.e “aa” is greater than “a”.

“ab” is greater than “aa”. “bcc” is smaller than “bcd”.

Question 16

#include < iostream >
#include < cstring >
using namespace std;

int main()
{
char str[5];
str = “gfg”;
//strcpy(str, “gfg”);
cout &laquo_space;str;
return 0;
}
~~~

~~~

Answer 16

o/p:

Compile error:

prog.cpp: In function ‘int main()’: prog.cpp:8:9: error: incompatible types in assignment of ‘const char [4]’ to ‘char [5]’ str = “gfg”; ^

Resolution:

To resolve the above error, use strcpy to copy the string.

Question 17

Output?

#include < iostream >
#include < cstring >
using namespace std;
~~~

int main()
{
string str = “geeksforgeeks”;
cout &laquo_space;str.length() &laquo_space;” “;
str = str + “xyz”;
cout &laquo_space;str &laquo_space;” “;
cout &laquo_space;str.substr(1, 3) &laquo_space;” “;
cout &laquo_space;str.find(“eek”) &laquo_space;” “;
return 0;
}
~~~

Answer 17

O/p:

13 geeksforgeeksxyz eek 1

string is a class in C++. So, it will have members and functions. Here str is an object and length, substr, find are functions. '+ "xyz"' is a operator overload, where it concatenates the string.

find() here will find the string in the given string and return the starting index of the found string, else it returns string::npos which sopecifies no position/string found.

Question 18

#include < iostream >
#include < cstring >
using namespace std;

int main()
{
    string str;
    cout << "Enter your name";
    getline(cin, str);
    cout << "\nYour name is " << str;
    return 0;
}

Answer 18

Using getline, we can read the input in a continuous string with spaces, until an enter is hit.

Question 19

#include < iostream >
#include < cstring >
using namespace std;

int main()
{
    string str;
    cout << "Enter your name";
    getline(cin, str, 'e');
    cout << "\nYour name is " << str;
    return 0;
}

Input: Sandeep

Answer 19

O/p: Sand

Question 20

#include < iostream >
using namespace std;

int main()
{
    int x = 10;
    int &y = x;
    cout << y << " ";
    x = x + 5;
    cout << y << " ";
    y = y + 5;
    cout << x << " ";
    return 0;
}

Answer 20

O/p:

10 15 20

• References create an alias
• Must be assigned when declared
• Cannot refer to another location once assigned
• Cannot be NULL
• Safer than pointers
• Easy to use(without any dereference, etc., like pointers)

Question 21

#include < iostream >
using namespace std;

void swap(int &x, int &y)
{
int temp = x;
x = y;
y = temp;
}
~~~

int main()
{
int x = 10, y = 15;
swap(x, y);
cout &laquo_space;x &laquo_space;” “ &laquo_space;y;
return 0;
}
~~~

Answer 21

O/P:

15 10

• When references are removed in the swap() here the exchange will fail

Question 22

Output?

#include < iostream >
#include < bits stdc++.h >
~~~

using namespace std;

void Print(vector &v)
{
    for(auto x: v)
        cout << x << " ";
}

int main()
{
    vector < int > v;
    for (int i = 0; i < 1000; i++)
        v.push_back(i);
    Print(v);
    return 0;
}

~~~

Answer 22

O/P:

• Prints from 1 to 1000. But, an important point to note here is when we use a reference the copy of vector is not created when Print() is called unless regular variables do.
• So, references are good and easy to use to refer to large objects like here in this example, which avoids unwanted copies.

Question 23

Output?

#include < iostream >
#include < bits/stdc++.h >
using namespace std;
~~~

int main() 
{
    vector < int > vect{10, 20, 30, 40};
    for(auto x: vect)
        x = x+5;
    for (auto x: vect)
        cout << x << " ";
    return 0;
}

~~~

Answer 23

O/p:

10 20 30 40

• When reference is not used a copy of vector is created by x variable in for each loop here.
• So, as x is not referenced to original vector, values are not modified in original vector.
• By using reference here, the variable x will be referenced and avoid copy as below:

int main() 
{
    vector < int > vect{10, 20, 30, 40};
    for(auto &x: vect)
        x = x+5;
    for (auto x: vect)
        cout << x << " ";
    return 0;
}

O/p: 15 25 35 45

Question 24

#include < iostream >
#include < bits/stdc++.h >  
using namespace std;

int main()
{
vector vect{“geeksforgeeks practice”, “geeksforgeeks ide”, “geeksforgeeks write”};
for (const auto &x: vect)
cout &laquo_space;x &laquo_space;” “;
return 0;
}
~~~

~~~

Answer 24

O/p:

geeksforgeeks practice geeksforgeeks ide geeksforgeeks write

• Having const reference will avoid modifying the original variable referenced.

Question 25

#include < iostream >
#include < bits/stdc++.h >  
using namespace std;

int main()
{
vector vect{10, 20, 30, 40};
for(const auto &x: vect)
x = x+5;
for (auto x: vect)
cout &laquo_space;x &laquo_space;” “;
return 0;
}
~~~

~~~

Answer 25

O/p:

Compile error:

In function ‘int main()’: prog.cpp:9:11: error: assignment of read-only reference ‘x’ x = x+5;

Question 26

#include < iostream >
using namespace std;

int main()
{
int x = 10, z = 20;
int &y = x;
y = z;
y = y+5;
cout &laquo_space;x &laquo_space;” “ &laquo_space;y &laquo_space;” “ &laquo_space;z;
return 0;
}
~~~

~~~

Answer 26

O/P:

25 25 20

• References once assigned, cannot be referenced to other
• Here value of z is assigned to both x and y, as they are referencing to same location, but z will not be referenced again.

Question 27

Output?

#include < iostream >
using namespace std;
~~~

int &fun()
{
    static int x = 10;
    return x;
}
int main()
{
    int &z = fun();
    cout << fun() << " ";
    z = 30;
    cout << fun();
    return 0;
}

~~~

Answer 27

O/p:

10 30

• Note: Never return non-static variable as a reference, as the value will be lost. Only with static, the value is still retained even after function return.

Question 28

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {10, 20};
int p1 = arr;
++p1;
cout &laquo_space;arr[0] &laquo_space;” “ «
arr[1] &laquo_space;” “ &laquo_space;*p1;
return 0;
}
~~~

Answer 28

O/P:

10 20 11

Here, * ++ have the same precedence, so associativity applies from left to right, and expression is read as ++(*p1).

Question 29

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {10, 20};
int *p2 = arr;
*p2++;
cout &laquo_space;arr[0] &laquo_space;” “ «
arr[1] &laquo_space;” “ &laquo_space;*p2;
return 0;
}
~~~

Answer 29

O/P:

10 20 20

Question 30

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {10, 20};
int *p2 = arr;
cout &laquo_space;*p2++ &laquo_space;” “;
cout &laquo_space;arr[0] &laquo_space;” “ «
arr[1] &laquo_space;” “ &laquo_space;*p2;
return 0;
}
~~~

Answer 30

O/p:

10 10 20 20

Question 31

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {10, 20};
int *p3 = arr;
*++p3;
cout &laquo_space;arr[0] &laquo_space;” “ «
arr[1] &laquo_space;” “ &laquo_space;*p3;
return 0;
}
~~~

Answer 31

O/P:

10 20 20

Question 32

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {10, 20};
int *p3 = arr;
cout &laquo_space;*++p3 &laquo_space;” “;
cout &laquo_space;arr[0] &laquo_space;” “ «
arr[1] &laquo_space;” “ &laquo_space;*p3;
return 0;
}
~~~

Answer 32

O/P:

20 10 20 20

Question 33

Output?

#include < iostream >
using namespace std;
~~~

int main() {
    char arr[] = {1, 2, 3};
    char *ptr = arr;
    cout << sizeof(arr) << " ";
    cout << sizeof(ptr) << " ";
    return 0;
}

~~~

Answer 33

O/P:

3 8

Question 34

Output?

#include < iostream >
using namespace std;
~~~

int main() {
    int arr[] = {1, 2, 3};
    int *ptr = arr;
    cout << sizeof(arr) << " ";
    cout << sizeof(ptr) << " ";
    return 0;
}

~~~

Answer 34

O/p:

12 8

Question 35

Output?

#include < iostream >
using namespace std;
~~~

int main() {
int arr[] = {20, 30, 40, 50};
int *ptr = arr;
cout &laquo_space;*(ptr + 2);
}
~~~

Answer 35

O/P:

40

Question 36

Output?

#include < stdio.h >

struct Point
{
  int x;
  int y;
};

int main()
{
struct Point p = {.y = 10};
struct Point t;
printf(“%d %d”, t.x, p.x);
return 0;
}
~~~

~~~

Answer 36

O/p:

Random value(121332) 0

Struct initialized partially gets default values as 0 for uninitialized variables in the struct.

If the struct is not initialized at all, it will get random values.

Question 37

#include < iostream >
using namespace std;

struct Student
{
  int roll;
  int age;
  string name;
  string address;
};

void print(const Student &s)
{
   cout << s.roll << ' '
        << s.name << ' '
        << s.age << ' '
        << s.address;
}

int main()
{
Student s = {2323, 38, “Sandeep”, “GFG”};
print(s);
return 0;
}
~~~

~~~

Answer 37

O/p:

2323 Sandeep 38 GFG

Question 38

#include < iostream >
using namespace std;

class BaseClass
{
public:
//make private variables public
int x;
};
~~~

//make derivation public also
class DerivedClass : public BaseClass {};

struct BaseStruct
{
    int x;
};
// Need not specify public keyword
struct DerivedStruct : BaseStruct {};

int main()
{
{
DerivedStruct d;
d.x = 20;
cout &laquo_space;d.x &laquo_space;‘\n’;
}

{
    DerivedClass d;
    d.x = 20;
    cout << d.x << '\n';
}

return 0; } ~~~

Answer 38

O/p:

20 20

• Structures have same functionality as classes, except that structure members are public by default and classes have private members by default.
• A structure can have cconstructor, member functions exactly like classes, if we have to make default members to be private, can be declared as private.

Question 39

When to use a Struct and Class?

Answer 39

• When purely object-oriented software is being designed, it is recommended to use Class to leverage the pure OO behavior of classes.
• When we are designing a mathematical or functional behaved software, we can use Struct