In programming, a function is a block of code that performs a computational task. (In practice, people write functions that perform many tasks, which is not very good, but it’s a topic beyond the purpose of this article). Functions are a fundamental concept of programming languages and C++ makes no exception. In fact, in C++ there is a large variety of functions that has evolved over time. In this article, I will give a brief walkthrough of this evolution starting with C++11. Since there are many things to talk about, I will not get into too many details on these topics but will provide various links for you to follow if you want to learn more.<\/p>\n\n\n\n\n\n\n\t\t\t\t
Let’s start briefly with what he had before “modern” times.<\/p>\n\n\n\n
Functions were available since the beginning of C++, whose first variant was called C with classes<\/em>. This is how a function looks:<\/p>\n\n\n\n This is what we call a non-member function<\/em><\/strong> or a free function<\/strong><\/em>, because it does not belong to any class. There are also member functions, that are part of a class\/struct. These are also referred as methods<\/em><\/strong> (like in most other object-oriented programming languages), although this term is not used anywhere in the C++ standard. Here is an example:<\/p>\n\n\n\n There are multiple kinds of functions, including the following:<\/p>\n\n\n\n All these are very simple examples but the point here is not to detail all these features that existed before modern C++. One thing that is missing here, though, is templates. Templates are blueprints that define families of functions or classes. The compiler instantiates actual overloads (in the case of function templates) from their use. Here is an example:<\/p>\n\n\n\n Now that we’ve briefly looked at these, let’s see what changes modern C++ brought.<\/p>\n\n\n\n These are function templates with a variable number of arguments.<\/p>\n\n\n\n The ellipsis ( See also:<\/strong><\/p>\n\n\n\n The return type of a function can be placed at the end of the function declaration, after the In C++11, this is not of much help for non-template functions, but it’s important for some function templates. Consider a version of What should the return type be? With the alternative function syntax we can place the return at the end of the expression and specify it with a See also:<\/strong><\/p>\n\n\n\n These are functions that can<\/em> be evaluated at compile-time. The result of evaluating such a function is a compile-time value that can be used anywhere compile-time values are required. To make a function constexpr you need to define it with the Just because a function is declared See also:<\/strong><\/p>\n\n\n\n These new specifies help us better describe virtual functions in derived classes.<\/p>\n\n\n\n The The It should be mentioned that the See also:<\/strong><\/p>\n\n\n\n Move semantics are not easy to describe in one sentence. Basically, it’s a language feature that enables the transfer of ownership of a resource from one object to another. Their purpose is improving performance by avoiding copies of resources that are not really necessary. For classes, these bring two new special functions: move constructor<\/em><\/strong> and move assignment operator<\/em><\/strong>:<\/p>\n\n\n\n See also:<\/p>\n\n\n\n The special member functions (see above) can be generated by the compiler. However, this does not happen in some circumstances. For instance, if any user-defined constructor exists, a default constructor is not generated, or if a move constructor or move assignment operator is defined, then no copy constructor and copy assignment operator is generated. Rather than implementing these by yourself you can explicitly ask the compiler to generate the default implementation, using the On the other hand, sometimes we need some functions or some function overloads to not be available. We can prevent a function from being called by defining it with the Any function can be deleted, not just member functions, or special member functions (as shown in the previous example).<\/p>\n\n\n\n See also:<\/p>\n\n\n\n Lambdas are not really functions in C++ and the term lambda function<\/strong><\/em> is incorrect. The right term is lambda expressions<\/em><\/strong>. Lambdas are syntactic sugar for creating unnamed function objects (which can capture variables in scope). A function object is a class with an overloaded call operator.<\/p>\n\n\n\n The compiler would generate something as follows (conceptually, as the details may vary):<\/p>\n\n\n\n Lambdas are useful for encapsulating a few lines of code that are then passed to functions such as general purpose algorithms or asynchronous functions.<\/p>\n\n\n\n See also:<\/strong><\/p>\n\n\n\n The alternative function syntax with trailing return type got simplified in C++14 with the compiler being able to deduce the return type from the return expression(s) present in the body of a function. Therefore, functions can be simplified as follows:<\/p>\n\n\n\n Again, this is more useful in template code:<\/p>\n\n\n\n See also:<\/strong><\/p>\n\n\n\n A generic lambda is a lambda expression with at least one parameter specified with the This has the effect that the anonymous structure generated by the compiler has a template function call operator. For the above example, it would look, at least conceptually, as follows:<\/p>\n\n\n\n See also:<\/strong><\/p>\n\n\n\n Constexpr functions from C++11 can be evaluated either at compile-time (if all arguments are compile-time values) or runtime. C++20 adds a new categories of functions, called immediate functions<\/em><\/strong>, that must be evaluated at compile-time. They always produce a compile-time expression and they are always visible only at compile-time. Symbols are not emitted for these functions, you cannot take the address of such functions, and tools such as debuggers will not be able to show them. <\/p>\n\n\n\n These functions are defined using the new A See also:<\/strong><\/p>\n\n\n\n If you find template syntax ugly or difficult this feature is for you. It allows you to write function templates without using template syntax. Instead, you use the auto specifier to define function parameters. A function with a least one parameter specified with the auto specifier is an abbreviated function template:<\/p>\n\n\n\n The compiler transforms this into a function template:<\/p>\n\n\n\n These are actually called unconstrained abbreviated function templates<\/em><\/strong> because there are no constraints on the template arguments. However, you can specify constraints with the help of concepts. Such functions are called constrained abbreviated function templates<\/em><\/strong>.<\/p>\n\n\n\n This is the same as follows:<\/p>\n\n\n\nint add(int a, int b)\n{\n return a + b;\n}<\/pre>\n\n\n\nclass math\n{\npublic:\n int add(int a, int b)\n {\n return a + b;\n }\n};<\/pre>\n\n\n\nint add(int a, int b) {return a + b;}\ndouble add(double a, double b) {return a + b;}<\/pre>\n\n\n\nstatic int add(int a, int b) {return a + b;}\n\nstruct math\n{\n static int add(int a, int b) {return a + b;}\n}<\/pre>\n\n\n\ninline int add(int a, int b) {return a + b;}\n\nstruct math\n{\n inline int add(int a, int b);\n}\n\nint match::add(int a, int b) {return a + b;}<\/pre>\n\n\n\nstd::string operator+(std::string const & txt, int n)\n{\n return txt + std::to_string(n); \/\/ channels your JavaScript energy\n}<\/pre>\n\n\n\nclass wrapper\n{\npublic:\n wrapper(int a): value_(a) {}\n int get() const {return value_;}\nprivate:\n int value_;\n};<\/pre>\n\n\n\nstruct A\n{\n virtual void f() { std::cout << \"A::f()\\n\"; }\n};\n\nstruct B : public A\n{\n virtual void f() { std::cout << \"B::f()\\n\"; }\n};<\/pre>\n\n\n\nclass wrapper\n{\npublic:\n wrapper() : value_(0) {}\n wrapper(wrapper const & other) {value_ = other.value_; }\n wrapper& operator=(wrapper const & other) {if(this != &other) {value_ = other.value_;} }\n ~wrapper() {}\nprivate:\n int value_;\n};<\/pre>\n\n\n\ntemplate <typename T>\nT add(T a, T b)\n{\n return a + b;\n}<\/pre>\n\n\n\nC++11<\/h1>\n\n\n\n
Variadic function templates<\/h2>\n\n\n\n
template <typename T>\nT add(T a, T b)\n{\n return a + b;\n}\n\ntemplate <typename T, typename ...Ts> \/\/ [1]\nT add(T t, Ts ... rest) \/\/ [2]\n{\n return t + add(rest...); \/\/ [3]\n}<\/pre>\n\n\n\n...<\/code>) defines a parameter pack. We can have:<\/p>\n\n\n\ntypename ... Ts<\/code> at line [1]<\/strong><\/li>Ts ... rest<\/code> at line [2]<\/strong><\/li>add(rest...)<\/code> at line [3]<\/strong><\/li><\/ul>\n\n\n\nAlternative function syntax<\/h2>\n\n\n\n
-><\/code> token:<\/p>\n\n\n\nauto add(int a, int b) -> int\n{\n return a + b;\n}<\/pre>\n\n\n\nadd()<\/code> that takes arguments of different types:<\/p>\n\n\n\ntemplate<typename T, typename U>\n??? add(T const & a, U const & b)\n{\n return a + b;\n}<\/pre>\n\n\n\ndecltype<\/code> expression:<\/p>\n\n\n\ntemplate<typename T, typename U>\nauto add(T const & a, U const & b) -> decltype(a + b)\n{\n return a + b;\n}<\/pre>\n\n\n\nconstexpr functions<\/h2>\n\n\n\n
constexpr<\/code> keyword, such as in the following example:<\/p>\n\n\n\ntemplate <typename T>\nconstexpr T add(T a, T b)\n{\n return a + b;\n}\n\nint main()\n{\n int arr[add(1,2)] = {1,2,3}; \/\/ [1]\n\n int a, b;\n std::cin >> a >> b;\n std::cout << add(a, b) << '\\n'; \/\/ [2]\n}<\/pre>\n\n\n\nconstexpr<\/code>, doesn’t mean it is evaluated at compile-time. In the above example:<\/p>\n\n\n\nadd<\/code> is evaluated at compile-time (line [1]) because all its arguments are integer literals<\/li>add<\/code> (at line [2]) is evaluated at runtime because its arguments are only know at runtime<\/li><\/ul>\n\n\n\nOverride and final specifiers for virtual functions<\/h2>\n\n\n\n
override<\/code> specifier used on a virtual function tells the compiler it is an overridden function of a base class virtual function. If the signature does not match, the compiler triggers an error.<\/p>\n\n\n\nstruct A\n{\n virtual void f(int) {}\n virtual void g() {}\n};\n\nstruct B : public A\n{\n void f(int) override {} \/\/ OK\n void g(char) override {} \/\/ error, g() does not override anything\n};<\/pre>\n\n\n\nfinal<\/code> specifier tells a compiler a virtual function can longer be overridden in a derived class.<\/p>\n\n\n\nstruct A\n{\n virtual void f() {}\n};\n\nstruct B : public A\n{\n void f() override final {}\n};\n\nstruct C : public B\n{\n void f() override {} \/\/ error, f cannot be overridden anymore\n};<\/pre>\n\n\n\nfinal<\/code> specifier can also be used on classes, in which case it prevents a class from being further derived.<\/p>\n\n\n\nMore special member functions<\/h2>\n\n\n\n
struct buffer\n{\n buffer() \/\/ default constructor\n :data_(nullptr), size_(0) \n {}\n \n explicit buffer(size_t size) \/\/ constructor\n :data_(new char[size]), size_(size)\n {}\n \n ~buffer() \/\/ destructor\n {\n delete [] data_;\n }\n \n buffer(buffer const & other) \/\/ copy constructor\n : data_(new char[other.size_])\n , size_(other.size_)\n {\n std::memcpy(data_, other.data_, size_);\n }\n \n buffer& operator=(buffer const & other) \/\/ copy assignment operator\n {\n if(this != &other)\n {\n delete [] data_;\n data_ = new char[other.size_];\n size_ = other.size_;\n std::memcpy(data_, other.data_, size_);\n }\n \n return *this;\n }\n \n buffer(buffer&& other) \/\/ move constructor\n : data_(std::move(other.data_))\n , size_(other.size_)\n {\n other.data_ = nullptr;\n other.size_ = 0;\n }\n \n buffer& operator=(buffer&& other) \/\/ move assignment operator\n {\n if(this != &other)\n {\n delete [] data_;\n data_ = std::move(other.data_);\n size_ = other.size_;\n other.data_ = nullptr;\n other.size_ = 0;\n }\n \n return *this;\n }\n \nprivate:\n char* data_;\n size_t size_;\n};\n\nint main()\n{\n buffer b1;\n buffer b2(10);\n buffer b3 = b2;\n buffer b4 = std::move(b3);\n}<\/pre>\n\n\n\nDefault and deleted functions<\/h2>\n\n\n\n
= default<\/code> specifier.<\/p>\n\n\n\nstruct foo\n{\n foo(int) {} \/\/ user-defined constructor\n foo() = default; \/\/ compiler generated default constructor\n};<\/pre>\n\n\n\n= delete<\/code> specifier:<\/p>\n\n\n\nstruct noncopyable\n{\n noncopyable() = default;\n noncopyable(noncopyable const &) = delete;\n noncopyable& operator=(noncopyable const &) = delete;\n};<\/pre>\n\n\n\ntemplate <typename T>\nT add(T a, T b)\n{\n return a + b;\n}\n\ntemplate <>\nint add<int>(int a, int b) = delete;\n\nint main()\n{\n add(1, 2); \/\/ error, this specialization is deleted\n}<\/pre>\n\n\n\n= delete<\/code>)<\/a><\/li>Lambdas<\/h2>\n\n\n\n
int main()\n{\n auto add = [](int a, int b) { return a + b; };\n add(1, 2);\n}<\/pre>\n\n\n\nint main()\n{\n class __lambda_1_10\n {\n public: \n inline int operator()(int a, int b) const\n {\n return a + b;\n } \n };\n \n __lambda_1_10 add = __lambda_1_10 {};\n add.operator()(1, 2);\n}<\/pre>\n\n\n\nint main()\n{\n std::vector<int> v {1, 5, 9, 2, 7};\n \n std::sort(v.begin(), v.end(), [](int a, int b){return a > b;}); \/\/ sorts descending\n \n for(const auto & e : v)\n std::cout << e << '\\n';\n}<\/pre>\n\n\n\nC++14<\/h1>\n\n\n\n
Function return type deduction<\/h2>\n\n\n\n
auto add(int a, int b)\n{\n return a + b;\n}<\/pre>\n\n\n\ntemplate <typename T, typename U>\nauto add(T a, U b)\n{\n return a + b;\n}<\/pre>\n\n\n\nGeneric lambdas<\/h2>\n\n\n\n
auto<\/code> specifier.<\/p>\n\n\n\nint main()\n{\n using namespace std::string_literals;\n \n auto add = [](auto a, auto b) {return a + b;};\n \n add(1, 2);\n add(1.0, 2.0);\n add(\"1\"s, \"2\"s);\n}<\/pre>\n\n\n\nint main()\n{\n using namespace std::string_literals;\n \n class __lambda_8_16\n {\n public: \n template <typename T0, typename T1>\n inline auto operator()(T0 a, T1 b) const\n {\n return a + b;\n }\n \n template<>\n inline int operator()(int a, int b) const\n {\n return a + b;\n }\n\n template<>\n inline double operator()(double a, double b) const\n {\n return a + b;\n }\n\n template<>\n inline std::string operator()(std::string a, std::string b) const\n {\n return std::operator+(a, b);\n }\n };\n \n __lambda_8_16 add = __lambda_8_16{};\n add.operator()(1, 2);\n add.operator()(1.0, 2.0);\n add.operator()(std::operator\"\"s(\"1\", 1UL), std::operator\"\"s(\"2\", 1UL));\n}\n<\/pre>\n\n\n\nC++20<\/h1>\n\n\n\n
Immediate functions<\/h2>\n\n\n\n
consteval<\/code> keyword. Here is an example:<\/p>\n\n\n\nconsteval int add(int const a, int const b)\n{\n return a + b;\n} \n\nint main()\n{\n constexpr int s1 = add(1, 2); \/\/ OK, compile-time evaluation\n int a = 12, b = 66;\n const int s2 = add(a, b); \/\/ error\n \n using fptr = int(int, int);\n fptr* padd = add; \/\/ error\n}<\/pre>\n\n\n\nconsteval<\/code> specifier implies inline<\/code>. A function that is consteval<\/code> is a constexpr<\/code> function, and must satisfy the requirements applicable to constexpr<\/code> functions (or constexpr<\/code> constructors).<\/p>\n\n\n\nAbbreviated function templates<\/h2>\n\n\n\n
auto add(auto a, auto b)\n{\n return a + b;\n}<\/pre>\n\n\n\ntemplate <typename T, typename U>\nauto add(T a, U b)\n{\n return a + b;\n}<\/pre>\n\n\n\nauto add(std::integral auto a, std::integral auto b)\n{\n return a + b;\n}<\/pre>\n\n\n\ntemplate <std::integral T, std::integral U>\nauto add(T a, U b)\n{\n return a + b;\n}<\/pre>\n\n\n\n