Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


This lesson is a quick introductory tour of functions within C++.  It is not intended for those who are entirely new to programming.  Rather, the people who may find it useful include:

- those who have completed our introductory course, but want a quick review
- those who are already familiar with programming in another language, but are new to C++
- those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course.  Those looking for more thorough explanations or additional context should consider completing _**Chapter 2**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


## Function Syntax


In C++, a function that is called `MyFunction` that returns `void` (ie, nothing) and does nothing looks like this:


```c++
void MyFunction() {}
```


Here are examples of functions that return data.  Note that we specify the return type in the function heading:


```c++
float ReturnFloat() {
  return 5.5f;
}

bool ReturnBool() {
  return true;
}
```


Similar to variables, return statements can be implicitly cast to the return type of the function:


```c++
// This returns the integer 5
int ReturnInt() {
  return 5.5f;
}
```


We invoke functions using their name, and the `()` operator:


```c++
ReturnFloat();
```


<Ad />


## The `main` Function


Our program needs to define an entry point - the function that will be run when our program is executed.


This is typically a function that returns an `int` and is called `main`:


```c++
int main() {
  return 0;
}
```


The return value of the `main` function is an exit code, which describes why our program stopped.  Returning `0` indicates the program ran as expected.  Any other number is an error code.


If the `main` function returns nothing, it is assumed to have returned `0`.  This is a behavior that is specific just to the `main` function.  Every other function must return something of the type specified in its heading, or something that can be converted to that type.


```c++
// This is valid
int main() {}

// This is not valid
int SomeFunction() {} //<e>
```


## Function Parameters and Arguments


We define parameters between the `()` in the function definition.  We specify their type and name, and separate multiple parameters using commas.  Below, we declare our function has two parameters, both of type `int`, which we’re calling `x` and `y`:


```c++
int Add(int x, int y) {
  return x + y;
}
```


We provide arguments for these parameters between the `(` and `)` when calling the function.  Below, we pass `1` to `x` and `2` to `y`:


```c++
int main() {
  Add(1, 2); // 3
}
```


<Aside>


### Arguments vs Parameters


A function’s _**arguments**_ are the values we pass to a function when we call it.


A function’s _**parameters**_ are the variables that receive those values, which we defined alongside the function’s name


These terms are sometimes used interchangably, when the meaning is clear from the context.


</Aside>


We can define default values for parameters, making them optional.  We do this using the `=` token within the function definition:


```c++
int Add(int x = 1, int y = 2) {
  return x + y;
}
```


We can pass `{}` as an argument to use the default value in that position, or omit it entirely if it’s at the end of our argument list:


```c++
int Add(int x = 1, int y = 2) {
  return x + y;
}

int main() {
  // Use no defaults
  Add(3, 4); // 7

  // Use default for 1st parameter
  Add({}, 5); // 6

  // Use default for 2nd parameter
  Add(2, {}); // 4
  Add(2); // 4

  // Use default for both parameters
  Add({}, {}); // 3
  Add({}); // 3
  Add(); // 3
}

```


Function return types can be set to `auto` which will ask the compiler to infer what it should be based on the `return` statements:


```c++
// Compiler deduces it will return an int
auto Add(int x, int y) {
  return x + y;
}
```


<Aside>


### `auto` Function Parameters


Function parameters can also have a type of `auto`, but this doesn’t mean what we might expect.


Using `auto` in a function’s parameter list creates a _**function template**_.  We explain templates in detail later in this course.


</Aside>


<Ad />


## Implicit Argument Conversion


Like with variables, the compiler will attempt to implicitly convert function arguments and return values into the appropriate type.  It will only present an error if it cannot do the conversion.


```c++
// Will return 2
int GetInt() {
  return 2.5f;
}

int Add(int x, int y) {
  return x + y;
}

```


```c++
// All expressions will return 2
// they are equivalent to Add(2, 2)
Add(2, 2);
Add(2.5f, 2.5f);
Add(2, 2.5f);
Add(2.5, 2.5);

```


## Function Overloading


It’s possible to have two functions with the same name in the same scope.


The way the compiler determines which function we want to call is by comparing the argument types to the parameter types:


```c++
// Integer Overload
int Add(int x, int y) {
  return x + y;
}

// Float Overload
float Add(float x, float y) {
  return x + y;
}

Add(2, 2); // Calling Integer Overload
Add(2.5f, 2.5f); // Calling Float Overload

```


If it is ambiguous what function we want to call, the compiler will throw an error.  The following is ambiguous because the compiler doesn’t know which variation of `Add` to use:


```c++
Add(2, 2.5f); //<e>
```


It could convert the first argument to a `float`, and call the overloads that accept a (`float`, `float`) argument list.  Or, it could convert the second argument to an int, and call the (`int`, `int`) overload.


It doesn’t know what we want, so it throws an error.


```c++
//<o>
error: 'Add': overloaded functions have similar conversions
could be 'float Add(float,float)'
or       'int Add(int,int)'
trying to match argument list '(int, float)'
```


The following also throws an error, as we provide two `double` arguments.  A `double` can be converted to either a `float` or an `int` so again, we’re being ambiguous:


```c++
Add(2.5, 2.5); //<e>
```


```c++
//<o>
error: 'Add': ambiguous call to overloaded function
could be 'float Add(float,float)'
or       'int Add(int,int)'
trying to match argument list '(double, double)'
```


We can remove the ambiguity by explicitly casting our arguments to the desired type.


```c++
// Calling (int, int) Overload
Add(2, static_cast<int>(2.5f));

// Calling (float, float) Overload
Add(
  static_cast<float>(2.5),
  static_cast<float>(2.5)
);
```


<Ad />


## Forward Declaration


Functions can be declared and defined as separate statements.  A function declaration looks the same as a definition, but without the body:


```c++
int Add(int x, int y);
```


A function’s return type, name, and parameter types are often called the _**function prototype**_ or _**function signature**_.


Function prototypes technically don’t need to name their parameters:


```c++
int Add(int, int);
```


But it’s common to include the names, to remind ourselves (or other developers reading our code) what the parameters are for.


Function declarations allow our functions to be called even if they are not yet defined at the place where they are called.


This is referred to as a forward declaration:


```c++
int Add(int x, int y);

int main() {
  Add(1, 2);
}

int Add(int x, int y) {
  return x + y;
}
```


The difference between a declaration and a definition will become more important as we advance through this course.


<Ad />


## Global and Local Scope


We don’t necessarily have access to all of our functions and variables from anywhere in our program.


_**Scopes**_ define which variables are accessible, and from where.  Scopes are typically created any time we have a set of braces, `{` and `}`


For example, a function body creates a scope.


Expressions can access their own scope, and any ancestor (parent, grandparent, etc) scope:


```c++
// Global scope
int GlobalInt{0};

void MyFunction() {
  // Local scope
  int LocalInt{0};

  // This is fine - we're accessing
  // a variable in the parent scope
  GlobalInt++;
}
```


But they cannot access any descendant (child, grandchild, etc) scopes:


```c++
void MyFunction() {
  int LocalInt{0};

  {
    // Fine - LocalInt is in a parent scope
    ++LocalInt;
    int ChildInt{1};
  }

  // Error - we don't have access to child scope
  ChildInt++;
}
```


## Summary


In this lesson, we've covered the fundamentals of functions. We've seen how to define functions, call them, and control their visibility using scopes. Key takeaways:

- Functions are defined with a return type, name, and parameter list
- Functions can be called using their name and providing arguments
- Functions can be overloaded by providing different parameter types
- Forward declarations allow functions to be used before they are defined
- Variables can be global (accessible everywhere) or local (accessible only within a specific scope)

<FAQ>


```javascript
//<m>
{
  slug: 'when-to-use-default-arguments',
  title: 'When to Use Default Arguments in C++ Functions',
  question: 'In what situations is it beneficial to use default arguments for function parameters?',
}
```


Default arguments can be useful in several scenarios:

1. When a function has parameters that have a common default value. This allows callers to omit those arguments if they want to use the default.
2. When you want to extend a function's functionality without breaking existing code. You can add new parameters with default values, and existing callers won't need to change.

For example, consider a function that draws a shape:


```c++
void DrawShape(std::string name, int width,
  int height, int x = 0, int y = 0) {
  // Draw the shape...
}
```


By providing default values for `x` and `y`, we make them optional for the caller. Callers can use the defaults for a simple case:


```c++
// Draws at (0, 0)
DrawShape("Square", 10, 10);
```


Or they can provide custom values when needed:


```c++
// Draws at (100, 100)
DrawShape("Circle", 15, 15, 100, 100);
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'passing-by-value-vs-reference',
  title: 'Passing Arguments by Value vs Reference in C++',
  question: 'What is the difference between passing function arguments by value and by reference?',
}
```


When you pass an argument by value, a copy of the argument is made and used within the function. Changes to this copy do not affect the original argument.


When you pass an argument by reference, the function gets a reference to the original argument. Changes made to the reference will affect the original argument.


Here's an example:


```c++
#include <iostream>

void PassByValue(int x) { x = 10; }

void PassByReference(int& x) { x = 10; }

int main() {
  int value = 5;

  PassByValue(value);
  std::cout << value << std::endl; // Outputs 5

  PassByReference(value);
  std::cout << value << std::endl; // Outputs 10
}
```


```c++
//<o>
5
10
```


Passing by reference is useful when you want the function to modify the original argument, or when you want to avoid the overhead of copying large objects.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'function-overloading-best-practices',
  title: 'Best Practices for Function Overloading in C++',
  question: 'What are some best practices to follow when overloading functions in C++?',
}
```


When overloading functions, consider these best practices:

1. Overloads should perform similar operations. The function name should clearly express what the function does, regardless of the argument types.
2. Avoid ambiguous overloads. If implicit conversions could lead to multiple overloads being callable, the code will not compile.
3. Use const-correctness. If an overload doesn't modify its arguments, declare them as const.
4. Consider using templates. If your overloads only differ in types and not in logic, a template might be a better choice.

Here's an example of clear, unambiguous overloads:


```c++
#include <string>

void SaveData(const std::string& data);
void SaveData(int data);
```


And here's an example of ambiguous overloads:


```c++
void Process(int data);
void Process(double data);

Process(10);   // Fine
Process(4.2);  // Fine

// Ambiguous! Both Process(int) and
// Process(double) could be called.
Process(0);
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'forward-declaration-when-to-use',
  title: 'When to Use Forward Declarations in C++',
  question: 'In what situations should I use forward declarations in my C++ code?',
}
```


Forward declarations are useful in a few scenarios:

1. To break circular dependencies. If two classes or functions depend on each other, one of them can use a forward declaration to break the cycle.
2. To improve compilation speed. If a header file only uses pointers or references to a type, it can forward declare that type instead of #include-ing its definition. This reduces the amount of code that needs to be parsed when the header is included.

For example, consider these two classes:


```c++
class A {
  B* b;
  // ...
};

class B {
  A* a;
  // ...
};
```


This code won't compile, because `A` needs to know about `B`, and `B` needs to know about `A`. We can fix this with a forward declaration:


```c++
class B; // Forward declaration

class A {
  B* b;
  // ...
};

class B {
  A* a;
  // ...
};
```


Now `A` knows that `B` exists (but not its full definition), which is enough for it to have a `B*` member.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'global-variables-pros-cons',
  title: 'Pros and Cons of Global Variables in C++',
  question: 'What are the advantages and disadvantages of using global variables in C++?',
}
```


Global variables are variables that are defined outside of any function and can be accessed from anywhere in the program. They have both advantages and disadvantages.


Advantages:

1. They can be accessed from anywhere in the program, which can be convenient.
2. They can be used to share data between functions without having to pass the data as arguments.

Disadvantages:

1. They can make code harder to understand and maintain, because it's not clear which functions are modifying the global state.
2. They introduce the potential for naming collisions. If two parts of the program use the same global variable name, it can lead to bugs.
3. They make code less modular and harder to reuse, because functions that use global variables are tied to the global state.

In general, it's considered good practice to minimize the use of global variables. When you do use them, make sure to give them clear, descriptive names and document their purpose and usage.


Here's an example of a global variable:


```c++
#include <iostream>

int globalCounter = 0;

void incrementCounter() { ++globalCounter; }

int main() {
  incrementCounter();
  incrementCounter();

  // Outputs 2
  std::cout << globalCounter;
}
```


```c++
//<o>
2
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'return-by-value-vs-reference',
  title: 'Returning by Value vs Reference in C++',
  question: 'When should I return by value from a function, and when should I return by reference?',
}
```


When deciding whether to return by value or by reference, consider these guidelines:

1. If you're returning a local variable or a temporary, you must return by value. Returning a reference to a local variable or a temporary will result in undefined behavior, because the referenced object will be destroyed when the function ends.
2. If you're returning a large object and want to avoid the cost of copying it, consider returning by const reference. This avoids the copy while still preventing the caller from modifying the object.
3. If you want the caller to be able to modify the returned object, and the object will outlive the function call, you can return by non-const reference.

Here's an example of each:


```c++
#include <string>

// Returns by value
std::string getNameValue() { return "John"; }

// Returns by const reference
const std::string& getNameConstRef() {
  static std::string name = "John";
  return name;
}

// Returns by non-const reference
std::string& getNameRef() {
  static std::string name = "John";
  return name;
}

int main() {
  std::string name1 = getNameValue();
  const std::string& name2 = getNameConstRef();
  std::string& name3 = getNameRef();

  // Modifies the static variable in getNameRef
  name3 = "Steve";
}
```


In general, prefer returning by value unless you have a good reason to return by reference.


</FAQ>



Learn the basics of writing and using functions in C++, including syntax, parameters, return types, and scope rules.

When to Use Default Arguments in C++ Functions

Passing Arguments by Value vs Reference in C++

Best Practices for Function Overloading in C++

When to Use Forward Declarations in C++

Pros and Cons of Global Variables in C++

Returning by Value vs Reference in C++

Added summary, published FAQs and updated references

Added AI assistant, table of contents and references

Intro to C++

Functions

Function declaration

Default arguments

Function Overloading

Function Overloading in C++

UPDATED FOR C++23 | Learn the basics of writing and using functions in C++, including syntax, parameters, return types, and scope rules | Clear explanations and simple code examples

Best Practices for Function Overloading in C++

What are some best practices to follow when overloading functions in C++?

Introduction to Functions

In what situations is it beneficial to use default arguments for function parameters?

What is the difference between passing function arguments by value and by reference?

In what situations should I use forward declarations in my C++ code?

What are the advantages and disadvantages of using global variables in C++?

When should I return by value from a function, and when should I return by reference?

Introduction to Functions

Professional C++

This course includes:

Professional C++