Declaring functions — cppreference.com

Original:

A function declaration introduces the function name and its type. It may appear in any scope, and is commonly placed in header files.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

A function definition provides the body of a function. It may only appear in namespace or class scope.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Déclaration de la fonction typique

Déclaration de fonction complète

Déclaration de la fonction globale avec le type de retour de fuite

Typique définition d'une fonction non-membre

Définition de fonction complète

Définition de la fonction globale avec le type de retour de fuite

Fonction membre virtuelle pure

Fonction membre défaillant

Supprimé fonction membre

#include <iostream>
#include <string>

// declaration in namespace(file) scope
// (the definition is provided later)
int f1();

// simple function with a default argument, returning nothing
void f0(const std::string& arg = "world") {
    std::cout << "Hello, " << arg << '\n';
}

// function returning a pointer to f0
auto fp11() -> void(*)(const std::string&) {
    return f0;
}

// function returning a pointer to f0, pre-C++11 style
void (*fp03())(const std::string&) {
    return f0;
}

int main()
{
    f0();
    fp11()("test");
    fp03()("again");
    int f2(std::string); // declaration in function scope
    std::cout << f2("bad12") << '\n';
}

// simple non-member function returning int
int f1() {
    return 42;
}

// function with an exception specification and a function try block
int f2(std::string str) noexcept try { 
    return std::stoi(str);
} catch(const std::exception& e) {
    std::cerr << "stoi() failed!\n";
    return 0;
}

Hello, world
Hello, test
Hello, again
stoi() failed!
0

#include <iostream>
#include <string>
#include <utility>
#include <exception>

struct S {
    int data;

    // simple converting constructor (declaration)
    S(int val);

    // simple explicit constructor (declaration)
    explicit S(std::string str);

    // const member function (definition)
    virtual int getData() const { return data; }
    
};

// definition of the constructor
S::S(int val) : data(val) {
    std::cout << "ctor1 called, data = " << data << '\n';
}

// this constructor has a catch clause
S::S(std::string str) try : data(std::stoi(str)) {
    std::cout << "ctor2 called, data = " << data << '\n';
} catch(const std::exception&) {
    std::cout << "ctor2 failed, string was '" << str << "'\n";
    throw; // ctor's catch clause should always rethrow
}

struct D : S {
    int data2;
    // constructor with a default argument
    D(int v1, int v2 = 11) : S(v1), data2(v2) {}

    // virtual member function
    int getData() const override { return data*data2; }

    // lvalue-only assignment operator
    D& operator=(D other) & {
        std::swap(other.data, data);
        std::swap(other.data2, data2);
        return *this;
    }
};

int main()
{
    D d1 = 1;
    S s2("2");
    try {
         S s3("not a number");
    } catch(const std::exception&) {}
    std::cout << s2.getData() << '\n';
    
   D d2(3, 4);
   d2 = d1; // OK: assignment to lvalue
//   D(5) = d1; // ERROR: no suitable overload of operator=
}

ctor1 called, data = 1
ctor2 called, data = 2
ctor2 failed, string was 'not a number'
2
ctor1 called, data = 3