Types de fonctions C ++

J'ai un problème de compréhension des types de fonction (ils apparaissent par exemple comme le Signature paramètre de modèle de std::function):

typedef int Signature(int); //the signature in question

typedef std::function<int(int)>  std_fun_1;
typedef std::function<Signature> std_fun_2;

static_assert(std::is_same<std_fun_1, std_fun_2>::value,
              "They are the same, cool.");

int square(int x) { return x*x; }

Signature* pf = square;   //pf is a function pointer, easy
Signature f;              //but what the hell is this?
f(42);                    //this compiles but doesn't link

La variable f ne peut pas être cédé, mais peut être appelé. Bizarre. Qu'est-ce bon pour, alors?

Maintenant, si je const-qualifier les typedef, je peux toujours l'utiliser pour construire d'autres types, mais, apparemment, rien d'autre:

typedef int ConstSig(int) const;

typedef std::function<int(int) const>  std_fun_3;
typedef std::function<ConstSig>        std_fun_4;

static_assert(std::is_same<std_fun_3, std_fun_4>::value,
              "Also the same, ok.");

ConstSig* pfc = square; //"Pointer to function type cannot have const qualifier"
ConstSig fc;            //"Non-member function cannot have const qualifier"

Ce coin reculé de la langue ont frappé, je ici? Comment est cet étrange type appelé et ce que je peux l'utiliser pour l'extérieur des paramètres de modèle?

source d'informationauteur marton78

  1. 16

    Voici le paragraphe correspondant de la Norme. Il parle de lui-même.

    8.3.5/10

    Une définition de type de type de fonction peut être utilisé pour déclarer une fonction, mais ne doit pas être utilisé pour définir une fonction (8.4).

    Exemple:

    typedef void F();
F  fv;         //OK: equivalent to void fv();
F  fv { }      //ill-formed
void fv() { }  //OK: definition of fv

    Une définition de type d'un type de fonction dont la déclaration comprend un cv-qualifier-seq doit être utilisé pour déclarer le type de fonction pour un non-fonction membre statique, de déclarer le type de fonction à laquelle un pointeur sur membre fait référence, ou de déclarer la fonction de premier niveau de type d'une autre fonction typedef déclaration.

    Exemple:

    typedef int FIC(int) const;
FIC f;               //ill-formed: does not declare a member function
struct S {
  FIC f;             //OK
};
FIC S::*pm = &S::f;  //OK
  2. 0

    Dans votre cas, std_fun_1 et std_fun_2 sont des objets identiques avec le même type de signatures. Ils sont à la fois std::function<int(int)>et peut à la fois tenir des pointeurs de fonction ou remboursables par anticipation des objets de type int(int).

    pf est un pointeur vers int(int). C'est, il sert le même but que std::functionmais sans les machines de cette catégorie ou de soutien pour les instances de appelable objets.

    De même, std_fun_3 et std_fun_4 sont des objets identiques avec le même type de signature, et peut à la fois tenir des pointeurs de fonction ou remboursables par anticipation des objets de type int(int) const.

    De la même façon, pfc est un pointeur de fonction de type int(int) constet peut contenir des pointeurs vers des fonctions de ce type, mais pas les instances de appelable objets.

    Mais f et fc sont les déclarations de fonction.

    La ligne:

    Signature fc;

    Est identique équivalent à:

    int fc(int) const;

    Qui est une déclaration d'une fonction nommée fc de type int(int) const.

    Il n'y a rien d'étrange ici. Vous avez tout simplement qui s'est passé lors de la syntaxe que vous avez probablement déjà à comprendre, à partir d'un point de vue, vous n'êtes pas habitués à.