close
The Wayback Machine - https://web.archive.org/web/20241119200759/https://www.geeksforgeeks.org/functions-in-cpp/
Open In App

Functions in C++

Last Updated : 11 Oct, 2024
Summarize
Comments
Improve
Suggest changes
Like Article
Like
Save
Share
Report
News Follow

A function is a set of statements that takes input, does some specific computation, and produces output. The idea is to put some commonly or repeatedly done tasks together to make a function so that instead of writing the same code again and again for different inputs, we can call this function.
In simple terms, a function is a block of code that runs only when it is called.

Syntax:

Syntax of Function

Syntax of Function

Example:

C++
// C++ Program to demonstrate working of a function
#include <iostream>
using namespace std;

// Following function that takes two parameters 'x' and 'y'
// as input and returns max of two input numbers
int max(int x, int y)
{
    if (x > y)
        return x;
    else
        return y;
}

// main function that doesn't receive any parameter and
// returns integer
int main()
{
    int a = 10, b = 20;

    // Calling above function to find max of 'a' and 'b'
    int m = max(a, b);

    cout << "m is " << m;
    return 0;
}

Output
m is 20

Time complexity: O(1)

Space complexity: O(1)

Why Do We Need Functions?

  • Functions help us in reducing code redundancy. If functionality is performed at multiple places in software, then rather than writing the same code, again and again, we create a function and call it everywhere. This also helps in maintenance as we have to make changes in only one place if we make changes to the functionality in future.
  • Functions make code modular. Consider a big file having many lines of code. It becomes really simple to read and use the code,  if the code is divided into functions.
  • Functions provide abstraction. For example, we can use library functions without worrying about their internal work.

Function Declaration

A function declaration tells the compiler about the number of parameters, data types of parameters, and returns type of function. Writing parameter names in the function declaration is optional but it is necessary to put them in the definition. Below is an example of function declarations. (parameter names are not present in the below declarations) The C++ Course provides comprehensive lessons on defining and using functions, enhancing your programming skills.

Function Declaration in C++

Function Declaration

Example:

C++
// C++ Program to show function that takes
// two integers as parameters and returns
// an integer
int max(int, int);

// A function that takes an int
// pointer and an int variable
// as parameters and returns
// a pointer of type int
int* swap(int*, int);

// A function that takes
// a char as parameter and
// returns a reference variable
char* call(char b);

// A function that takes a
// char and an int as parameters
// and returns an integer
int fun(char, int);

Types of Functions

Types of Function in C++

Types of Function in C++

User Defined Function

User-defined functions are user/customer-defined blocks of code specially customized to reduce the complexity of big programs. They are also commonly known as “tailor-made functions” which are built only to satisfy the condition in which the user is facing issues meanwhile reducing the complexity of the whole program.

Library Function 

Library functions are also called “built-in Functions“. These functions are part of a compiler package that is already defined and consists of a special function with special and different meanings. Built-in Function gives us an edge as we can directly use them without defining them whereas in the user-defined function we have to declare and define a function before using them. 
For Example: sqrt(), setw(), strcat(), etc.

Parameter Passing to Functions

The parameters passed to the function are called actual parameters. For example, in the program below, 5 and 10 are actual parameters. 
The parameters received by the function are called formal parameters. For example, in the above program x and y are formal parameters. 

Formal Parameter and Actual Parameter in C++

Formal Parameter and Actual Parameter

There are two most popular ways to pass parameters:

  1. Pass by Value: In this parameter passing method, values of actual parameters are copied to the function’s formal parameters. The actual and formal parameters are stored in different memory locations so any changes made in the functions are not reflected in the actual parameters of the caller. 
     
  2. Pass by Reference: Both actual and formal parameters refer to the same locations, so any changes made inside the function are reflected in the actual parameters of the caller.

Function Definition

Pass by value is used where the value of x is not modified using the function fun().

C++
// C++ Program to demonstrate function definition
#include <iostream>
using namespace std;

void fun(int x)
{
    // definition of
    // function
    x = 30;
}

int main()
{
    int x = 20;
    fun(x);
    cout << "x = " << x;
    return 0;
}

Output
x = 20

Time complexity: O(1)

Space complexity: O(1)

Functions Using Pointers

The function fun() expects a pointer ptr to an integer (or an address of an integer). It modifies the value at the address ptr. The dereference operator * is used to access the value at an address. In the statement ‘*ptr = 30’, the value at address ptr is changed to 30. The address operator & is used to get the address of a variable of any data type. In the function call statement ‘fun(&x)’, the address of x is passed so that x can be modified using its address. 

C++
// C++ Program to demonstrate working of
// function using pointers
#include <iostream>
using namespace std;

void fun(int* ptr) { *ptr = 30; }

int main()
{
    int x = 20;
    fun(&x);
    cout << "x = " << x;

    return 0;
}

Output
x = 30

Time complexity: O(1)

Space complexity: O(1)

passing string as an argument:

In c++ we can pass string as as argument in various way

  1. Pass by Value
  2. Pass by Reference
  3. Pass by Pointer

1. Pass by Value

In this when you are passing a values as string it will make a copy of a string values.

C++
#include <iostream>
#include <string>

void printString(std::string str) {
    std::cout << str << std::endl;
}

int main() {
    std::string myString = "Hello, GFG!";
    printString(myString);
    return 0;
}

Output
Hello, GFG!

2. Pass by Reference

This can be done by using ‘&’ operator

C++
#include <iostream>
#include <string>

void printString(const std::string& str) { // Note the 'const' to prevent modification
    std::cout << str << std::endl;
}

int main() {
    std::string myString = "welcome to gfg";
    printString(myString);
    return 0;
}

Output
welcome to gfg


3. Pass by Pointer

This can be done by using * operator

C++
#include <iostream>
#include <string>

void printString(const std::string* str) { // Note the 'const' to prevent modification
    std::cout << *str << std::endl;
}

int main() {
    std::string myString = "This is Pss by pointer";
    printString(&myString);
    return 0;
}

Output
This is Pss by pointer


Returning string from a function:

This can be done by using the function “std::string”

C++
#include <iostream>
#include <string>

std::string getGreeting() {
    return "This is  C++";
}

int main() {
    std::string greeting = getGreeting();
    std::cout << greeting << std::endl;
    return 0;
}

Output
This is  C++


Returning a pointer from a function

we need to create a function that returns a pointer to an array of integers.

C++
#include <iostream>

int* createArray(int size) {
    int* arr = new int[size]; // Dynamically allocate memory for an array
    for (int i = 0; i < size; ++i) {
        arr[i] = i * 10; // Initialize array elements
    }
    return arr; // Return the pointer to the array
}

int main() {
    int size = 10;
    int* myArray = createArray(size); // Function returns a pointer to the array
    
    // Print the array
    for (int i = 0; i < size; ++i) {
        std::cout << myArray[i] << " ";
    }
    std::cout << std::endl;

    delete[] myArray; // Don't forget to free the allocated memory
    return 0;
}

Output
0 10 20 30 40 50 60 70 80 90 


Callback function (function passed as an argument in other function)

A callback function is a function that is passed as an argument to another function

C++
#include <iostream>

// Define a callback function type
typedef void (*CallbackFunction)();

// Function that takes a callback function as an argument
void performAction(CallbackFunction callback) {
    std::cout << "Performing some action...\n";
    // Call the callback function
    callback();
}

// Example callback function
void myCallback() {
    std::cout << "Callback function \n";
}

int main() {
    // Pass the callback function to performAction
    performAction(myCallback);
    return 0;
}

Output
Performing some action...
Callback function 

An array of function pointer and how the elements are accessed

Here, we have c++ example, for accessing elements from array

C++
#include <iostream>

// Function declarations
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    // Declare and initialize an array of function pointers
    int (*funcArray[3])(int, int) = { add, subtract, multiply };

    // Variables to use as function parameters
    int x = 2, y = 3;

    // Access and call the functions using the array of function pointers
    std::cout << "Add: " << funcArray[0](x, y) << std::endl;       // Calls add(10, 5)
    std::cout << "Subtract: " << funcArray[1](x, y) << std::endl;  // Calls subtract(10, 5)
    std::cout << "Multiply: " << funcArray[2](x, y) << std::endl;  // Calls multiply(10, 5)

    return 0;
}

Output
Add: 5
Subtract: -1
Multiply: 6

Difference between call by value and call by reference in C++ 

Call by valueCall by reference
A copy of the value is passed to the functionAn address of value is passed to the function
Changes made inside the function are not 
reflected on other functions
Changes made inside the function are reflected 
outside the function as well
Actual and formal arguments will be created at 
different memory location
Actual and formal arguments will be created at 
same memory location.

Points to Remember About Functions in C++

1. Most C++ program has a function called main() that is called by the operating system when a user runs the program. 

2. Every function has a return type. If a function doesn’t return any value, then void is used as a return type. Moreover, if the return type of the function is void, we still can use the return statement in the body of the function definition by not specifying any constant, variable, etc. with it, by only mentioning the ‘return;’ statement which would symbolize the termination of the function as shown below: 

C++
void function name(int a)
{
    ....... // Function Body
        return; // Function execution would get terminated
}


3. To declare a function that can only be called without any parameter, we should use “void fun(void)“. As a side note, in C++, an empty list means a function can only be called without any parameter. In C++, both void fun() and void fun(void) are same.

 

Main Function 

The main function is a special function. Every C++ program must contain a function named main. It serves as the entry point for the program. The computer will start running the code from the beginning of the main function. 

Types of Main Functions

1. Without parameters:

CPP
// Without Parameters
int main() { ... return 0; }

2. With parameters:

CPP
// With Parameters
int main(int argc, char* const argv[]) { ... return 0; }


The reason for having the parameter option for the main function is to allow input from the command line. When you use the main function with parameters, it saves every group of characters (separated by a space) after the program name as elements in an array named argv. 
Since the main function has the return type of int, the programmer must always have a return statement in the code. The number that is returned is used to inform the calling program what the result of the program’s execution was. Returning 0 signals that there were no problems.

C++ Recursion

When function is called within the same function, it is known as recursion in C++. The function which calls the same function, is known as recursive function.
A function that calls itself, and doesn’t perform any task after function call, is known as tail recursion. In tail recursion, we generally call the same function with return statement.
Syntax:

We have Direct recursion and in direct recursion

1. Direct Recursion:

it can be done when the function calls itself

C++
#include <iostream>
using namespace std;

void directRecursion(int n) {
    if (n > 0) {
        cout << n << " ";
        directRecursion(n - 1); // Function calls itself
    }
}

int main() {
    directRecursion(10);
    return 0;
}

Output
5 4 3 2 1 

2. Indirect Recursion

In this One function calls another function .

C++
#include <iostream>
using namespace std;

void indirectRecursionB(int n); // Forward declaration

void indirectRecursionA(int n) {
    if (n > 0) {
        cout << n << " ";
        indirectRecursionB(n - 1); // Function A calls Function B
    }
}

void indirectRecursionB(int n) {
    if (n > 1) {
        cout << n << " ";
        indirectRecursionA(n / 2); // Function B calls Function A
    }
}

int main() {
    indirectRecursionA(10);
    return 0;
}

Output
10 9 4 3 1 

Tail Recursion and Non-Tail Recursion:

1. Tail Recursion:

Tail recursion occurs when a function makes a recursive call as its last operation,

C++
#include <iostream>
using namespace std;

void tailRecursion(int n) {
    if (n > 0) {
        cout << n << " ";
        tailRecursion(n - 1); // Recursive call is the last operation
    }
}

int main() {
    tailRecursion(15);
    return 0;
}

Output
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 

2. Non-Tail Recursion

Non-tail recursion occurs when a function performs some operations after the recursive call.

C++
#include <iostream>
using namespace std;

int nonTailRecursion(int n) {
    if (n > 0) {
        return n + nonTailRecursion(n - 1); // Recursive call is not the last operation
    } else {
        return 0;
    }
}

int main() {
    int result = nonTailRecursion(20);
    cout << "Result: " << result << endl;
    return 0;
}

Output
Result: 210

To know more see this article.


C++ Passing Array to Function

In C++, to reuse the array logic, we can create a function. To pass an array to a function in C++,  we need to provide only the array name.

function_name(array_name[]); //passing array to function

Example: Print the minimum number in the given array.

C++
#include <iostream>
using namespace std;
void printMin(int arr[5]);
int main()
{
    int ar[5] = { 30, 10, 20, 40, 50 };
    printMin(ar); // passing array to function
}
void printMin(int arr[5])
{
    int min = arr[0];
    for (int i = 0; i < 5; i++) {
        if (min > arr[i]) {
            min = arr[i];
        }
    }
    cout << "Minimum element is: " << min << "\n";
}

// Code submitted by Susobhan Akhuli

Output
Minimum element is: 10

Time complexity: O(n) where n is the size of the array
Space complexity: O(n) where n is the size of the array.

C++ Overloading (Function)

If we create two or more members having the same name but different in number or type of parameters, it is known as C++ overloading. In C++, we can overload:

  • methods,
  • constructors and
  • indexed properties

Types of overloading in C++ are:

  • Function overloading
  • Operator overloading

C++ Function Overloading

Function Overloading is defined as the process of having two or more functions with the same name, but different parameters. In function overloading, the function is redefined by using either different types or number of arguments. It is only through these differences a compiler can differentiate between the functions.
The advantage of Function overloading is that it increases the readability of the program because you don’t need to use different names for the same action.

Example: changing number of arguments of add() method

C++
// program of function overloading when number of arguments
// vary
#include <iostream>
using namespace std;
class Cal {
public:
    static int add(int a, int b) { return a + b; }
    static int add(int a, int b, int c)
    {
        return a + b + c;
    }
};
int main(void)
{
    Cal C; // class object declaration.
    cout << C.add(10, 20) << endl;
    cout << C.add(12, 20, 23);
    return 0;
}

// Code Submitted By Susobhan Akhuli

Output
30
55

Time complexity: O(1)
Space complexity: O(1)

Example: when the type of the arguments vary.

C++
// Program of function overloading with different types of
// arguments.
#include <iostream>
using namespace std;
int mul(int, int);
float mul(float, int);

int mul(int a, int b) { return a * b; }
float mul(double x, int y) { return x * y; }
int main()
{
    int r1 = mul(6, 7);
    float r2 = mul(0.2, 3);
    cout << "r1 is : " << r1 << endl;
    cout << "r2 is : " << r2 << endl;
    return 0;
}

// Code Submitted By Susobhan Akhuli

Output
r1 is : 42
r2 is : 0.6

Time Complexity: O(1)
Space Complexity: O(1)

Function Overloading and Ambiguity

When the compiler is unable to decide which function is to be invoked among the overloaded function, this situation is known as function overloading ambiguity.
When the compiler shows the ambiguity error, the compiler does not run the program.

Causes of Ambiguity:

  • Type Conversion.
  • Function with default arguments.
  • Function with pass-by-reference.

Type Conversion:-

C++
#include <iostream>
using namespace std;
void fun(int);
void fun(float);
void fun(int i) { cout << "Value of i is : " << i << endl; }
void fun(float j)
{
    cout << "Value of j is : " << j << endl;
}
int main()
{
    fun(12);
    fun(1.2);
    return 0;
}

// Code Submitted By Susobhan Akhuli


The above example shows an error “call of overloaded ‘fun(double)’ is ambiguous“. The fun(10) will call the first function. The fun(1.2) calls the second function according to our prediction. But, this does not refer to any function as in C++, all the floating point constants are treated as double not as a float. If we replace float to double, the program works. Therefore, this is a type conversion from float to double.

Function with Default Arguments:-

C++
#include <iostream>
using namespace std;
void fun(int);
void fun(int, int);
void fun(int i) { cout << "Value of i is : " << i << endl; }
void fun(int a, int b = 9)
{
    cout << "Value of a is : " << a << endl;
    cout << "Value of b is : " << b << endl;
}
int main()
{
    fun(12);

    return 0;
}

// Code Submitted By Susobhan Akhuli


The above example shows an error “call of overloaded ‘fun(int)’ is ambiguous“. The fun(int a, int b=9) can be called in two ways: first is by calling the function with one argument, i.e., fun(12) and another way is calling the function with two arguments, i.e., fun(4,5). The fun(int i) function is invoked with one argument. Therefore, the compiler could not be able to select among fun(int i) and fun(int a,int b=9).

Function with Pass By Reference:-

C++
#include <iostream>
using namespace std;
void fun(int);
void fun(int&);
int main()
{
    int a = 10;
    fun(a); // error, which fun()?
    return 0;
}
void fun(int x) { cout << "Value of x is : " << x << endl; }
void fun(int& b)
{
    cout << "Value of b is : " << b << endl;
}

// Code Submitted By Susobhan Akhuli

The above example shows an error “call of overloaded ‘fun(int&)’ is ambiguous“. The first function takes one integer argument and the second function takes a reference parameter as an argument. In this case, the compiler does not know which function is needed by the user as there is no syntactical difference between the fun(int) and fun(int &).

Friend Function

  • A friend function is a special function in C++ which in spite of not being a member function of a class has the privilege to access private and protected data of a class.
  •  A friend function is a non-member function or an ordinary function of a class, which is declared by using the keyword “friend” inside the class. By declaring a function as a friend, all the access permissions are given to the function.
  • The keyword “friend” is placed only in the function declaration but not in the function definition.
  • When the friend function is called neither the name of the object nor the dot operator is used. However, it may accept the object as an argument whose value it wants to access.
  • A friend function can be declared in any section of the class i.e. public, private, or protected.

Declaration of friend function in C++

Syntax:

class <class_name> {    
friend <return_type> <function_name>(argument/s);
};


Example_1: Find the largest of two numbers using Friend Function

C++
#include <iostream>
using namespace std;
class Largest {
    int a, b, m;

public:
    void set_data();
    friend void find_max(Largest);
};

void Largest::set_data()
{
    cout << "Enter the first number : ";
    cin >> a;
    cout << "\nEnter the second number : ";
    cin >> b;
}

void find_max(Largest t)
{
    if (t.a > t.b)
        t.m = t.a;
    else
        t.m = t.b;

    cout << "\nLargest number is " << t.m;
}

int main()
{
    Largest l;
    l.set_data();
    find_max(l);
    return 0;
}


Output

Enter the first number : 789
Enter the second number : 982
Largest number is 982



Previous Article
Next Article

Similar Reads

Write one line functions for strcat() and strcmp()
Recursion can be used to do both tasks in one line. Below are one line implementations for stracat() and strcmp(). /* my_strcat(dest, src) copies data of src to dest. To do so, it first reaches end of the string dest using recursive calls my_strcat(++dest, src). Once end of dest is reached, data is copied using (*dest++ = *src++)? my_strcat(dest, s
2 min read
Virtual Functions in Derived Classes in C++
A virtual function is a member function of a base class that is overridden by a derived class. When you use a pointer or a reference to the base class to refer to a derived class object, you can call a virtual function for that object and have it run the derived class's version of the function. In C++, once a member function is declared as a virtua
2 min read
Virtual Functions and Runtime Polymorphism in C++
A virtual function is a member function that is declared in the base class using the keyword virtual and is re-defined (Overridden) in the derived class. It tells the compiler to perform late binding where the compiler matches the object with the right called function and executes it during the runtime. This technique falls under Runtime Polymorphi
8 min read
C | Functions | Question 11
Output of following program? #include <stdio.h> int main() { int i = 5; printf("%d %d %d", i++, i++, i++); return 0; } (A) 7 6 5 (B) 5 6 7 (C) 7 7 7 (D) Compiler Dependent Answer: (D) Explanation: When parameters are passed to a function, the value of every parameter is evaluated before being passed to the function. What is the orde
1 min read
C | Functions | Question 2
In C, parameters are always (A)Passed by value (B)Passed by reference (C)Non-pointer variables are passed by value and pointers are passed by reference (D)Passed by value result Answer: (A)Explanation: In C, function parameters are always passed by value. Pass-by-reference is simulated in C by explicitly passing pointer values. Quiz of this Questio
1 min read
C | Functions | Question 3
Which of the following is true about return type of functions in C? (A)Functions can return any type (B)Functions can return any type except array and functions (C)Functions can return any type except array, functions and union (D)Functions can return any type except array, functions, function pointer and union Answer: (B)Explanation: In C, functio
1 min read
C | Functions | Question 5
Output? #include <stdio.h> int main() { int (*ptr)(int ) = fun; (*ptr)(3); return 0; } int fun(int n) { for(;n > 0; n--) printf("GeeksQuiz "); return 0; } (A) GeeksQuiz GeeksQuiz GeeksQuiz (B) GeeksQuiz GeeksQuiz (C) Compiler Error (D) Runtime Error Answer: (C) Explanation: The only problem with program is fun is not declared/def
1 min read
C | Functions | Question 6
Output of following program? C/C++ Code #include void dynamic(int s, ...) { printf("%d", s); } int main() { dynamic(2, 4, 6, 8); dynamic(3, 6, 9); return 0; } (A) 2 3 (B) Compiler Error (C) 4 3 (D) 3 2 Answer: (A) Explanation: In c three continuous dots is known as ellipsis which is variable number of arguments of function. The values to parameters
1 min read
C | Functions | Question 7
Predict the output? #include <stdio.h> int main() { void demo(); void (*fun)(); fun = demo; (*fun)(); fun(); return 0; } void demo() { printf("GeeksQuiz "); } (A) GeeksQuiz (B) GeeksQuiz GeeksQuiz (C) Compiler Error (D) Blank Screen Answer: (B) Explanation: This is a simple program with function pointers. fun is assigned to point to
1 min read
C | Functions | Question 8
What is the meaning of using extern before function declaration? For example following function sum is made extern extern int sum(int x, int y, int z) { return (x + y + z); } (A) Function is made globally available (B) extern means nothing, sum() is same without extern keyword. (C) Function need not to be declared before its use (D) Function is mad
1 min read
C | Functions | Question 9
What is the meaning of using static before function declaration? For example following function sum is made static static int sum(int x, int y, int z) { return (x + y + z); } (A) Static means nothing, sum() is same without static keyword. (B) Function need not to be declared before its use (C) Access to static functions is restricted to the file wh
1 min read
C | Functions | Question 10
In C, what is the meaning of following function prototype with empty parameter list void fun() { /* .... */ } (A) Function can only be called without any parameter (B) Function can be called with any number of parameters of any types (C) Function can be called with any number of integer parameters. (D) Function can be called with one integer parame
1 min read
C++ | Virtual Functions | Question 1
Which of the following is true about virtual functions in C++. (A) Virtual functions are functions that can be overridden in derived class with the same signature. (B) Virtual functions enable run-time polymorphism in a inheritance hierarchy. (C) If a function is 'virtual' in the base class, the most-derived class's implementation of the function i
1 min read
C++ | Virtual Functions | Question 2
Predict output of the following program #include<iostream> using namespace std; class Base { public: virtual void show() { cout<<" In Base \n"; } }; class Derived: public Base { public: void show() { cout<<"In Derived \n"; } }; int main(void) { Base *bp = new Derived; bp->show(); Base &br = *bp; br.show(
1 min read
C++ | Virtual Functions | Question 3
Output of following program #include<iostream> using namespace std; class Base { public: virtual void show() { cout<<" In Base \n"; } }; class Derived: public Base { public: void show() { cout<<"In Derived \n"; } }; int main(void) { Base *bp, b; Derived d; bp = &d; bp->show(); bp = &b; bp->show();
1 min read
C++ | Virtual Functions | Question 5
#include<iostream> using namespace std; class Base { public: virtual void show() = 0; }; int main(void) { Base b; Base *bp; return 0; } (A) There are compiler errors in lines "Base b;" and "Base bp;" (B) There is compiler error in line "Base b;" (C) There is compiler error in line "Base bp;" (D) No compiler Error Answer: (B) Explanation: Sinc
1 min read
C++ | Virtual Functions | Question 6
Predict the output of following program. #include<iostream> using namespace std; class Base { public: virtual void show() = 0; }; class Derived : public Base { }; int main(void) { Derived q; return 0; } (A) Compiler Error: there cannot be an empty derived class (B) Compiler Error: Derived is abstract (C) No compiler Error Answer: (B) Explanat
1 min read
C++ | Virtual Functions | Question 7
#include<iostream> using namespace std; class Base { public: virtual void show() = 0; }; class Derived: public Base { public: void show() { cout<<"In Derived \n"; } }; int main(void) { Derived d; Base &br = d; br.show(); return 0; } (A) Compiler Error in line "Base &br = d;" (B) Empty Output (C) In Derived Answer: (C)
1 min read
C++ | Virtual Functions | Question 14
Can a constructor be virtual? Will the following program compile? #include <iostream> using namespace std; class Base { public: virtual Base() {} }; int main() { return 0; } (A) Yes (B) No Answer: (B) Explanation: There is nothing like Virtual Constructor. Making constructors virtual doesn't make sense as constructor is responsible for creati
1 min read
C++ | Virtual Functions | Question 9
Can a destructor be virtual? Will the following program compile? #include <iostream> using namespace std; class Base { public: virtual ~Base() {} }; int main() { return 0; } (A) Yes (B) No Answer: (A) Explanation: A destructor can be virtual. We may want to call appropriate destructor when a base class pointer points to a derived class object
1 min read
C++ | Virtual Functions | Question 10
#include<iostream> using namespace std; class Base { public: Base() { cout<<"Constructor: Base"<<endl; } virtual ~Base() { cout<<"Destructor : Base"<<endl; } }; class Derived: public Base { public: Derived() { cout<<"Constructor: Derived"<<endl; } ~Derived() { cout<<
1 min read
C++ | Virtual Functions | Question 11
Can static functions be virtual? Will the following program compile? #include<iostream>  using namespace std;      class Test {    public:       virtual static void fun()  { } }; (A) Yes (B) No Answer: (B) Explanation: Static functions are class specific and may not be called on objects. Virtual functions are called according to the pointed o
1 min read
C++ | Virtual Functions | Question 12
Predict the output of following C++ program. Assume that there is no alignment and a typical implementation of virtual functions is done by the compiler. #include <iostream> using namespace std; class A { public: virtual void fun(); }; class B { public: void fun(); }; int main() { int a = sizeof(A), b = sizeof(B); if (a == b) cout <<
1 min read
C++ | Virtual Functions | Question 13
#include <iostream> using namespace std; class A { public: virtual void fun() { cout << "A::fun() "; } }; class B: public A { public: void fun() { cout << "B::fun() "; } }; class C: public B { public: void fun() { cout << "C::fun() "; } }; int main() { B *bp = new C; bp->fun(); return 0; } (A
1 min read
C++ | Virtual Functions | Question 14
Predict the output of following C++ program #include<iostream> using namespace std; class Base { public: virtual void show() { cout<<" In Base \n"; } }; class Derived: public Base { public: void show() { cout<<"In Derived \n"; } }; int main(void) { Base *bp = new Derived; bp->Base::show(); // Note the use of
1 min read
Algorithm Library Functions in C++ STL
Non-modifying sequence operations std :: all_of : Test condition on all elements in rangestd :: any_of : Test if any element in range fulfills conditionstd :: none_of : Test if no elements fulfill conditionstd :: for_each : Apply function to rangestd :: find : Find value in rangestd :: find_if : Find element in rangestd :: find_if_not : Find elemen
4 min read
asin() and atan() functions in C/C++ with Example
In C++, asin() and atan() is a predefined function used for mathematical calculations. math.h is the header file required for various mathematical functions. All the functions available in this library take double as an argument and return double as the result. asin() Method asin() function is used to find the arc sine of a number means give a sin
3 min read
Explicitly Defaulted and Deleted Functions in C++ 11
Defaulted Function What is a Defaulted Function? Explicitly defaulted function declaration is a new form of function declaration that is introduced into the C++11 standard which allows you to append the '=default;' specifier to the end of a function declaration to declare that function as an explicitly defaulted function. This makes the compiler ge
5 min read
beta(), betaf() and betal() functions in C++ STL
The beta(), betaf() and betal() are built-in functions in C++ STL that are used to compute the beta functionof two positive real values. The function takes two variables x and y as input and returns the beta function of x and y. Beta function (Also known as Euler integral of first kind) of x and y can be defined as: [Tex]$$B(x, y)=\int_0^1 t^{x-1}
3 min read
Types of User Defined Functions in C
A user-defined function is one that is defined by the user when writing any program, as we do not have library functions that have predefined definitions. To meet the specific requirements of the user, the user has to develop his or her own functions. Such functions must be defined properly by the user. There is no such kind of requirement to add a
4 min read
Article Tags :
Practice Tags :
three90RightbarBannerImg