Est-il possible d'implémenter staticdes fonctions membres de classe dans le fichier * .cpp au lieu de le faire dans le fichier d'en-tête?

Toutes les staticfonctions sont-elles toujours inline?

C'est.

test.hpp:

class A {
public:
    static int a(int i);
};

test.cpp:

#include <iostream>
#include "test.hpp"


int A::a(int i) {
    return i + 2;
}

using namespace std;
int main() {
    cout << A::a(4) << endl;
}

Ils ne sont pas toujours en ligne, non, mais le compilateur peut les créer.

Essaye ça:

header.hxx:

class CFoo
{
public: 
    static bool IsThisThingOn();
};

class.cxx:

#include "header.hxx"
bool CFoo::IsThisThingOn() // note: no static keyword here
{
    return true;
}

helper.hxx

class helper
{
 public: 
   static void fn1 () 
   { /* defined in header itself */ }

   /* fn2 defined in src file helper.cxx */
   static void fn2(); 
};

helper.cxx

#include "helper.hxx"
void helper::fn2()
{
  /* fn2 defined in helper.cxx */
  /* do something */
}

A.cxx

#include "helper.hxx"
A::foo() {
  helper::fn1(); 
  helper::fn2();
}

Pour en savoir plus sur la façon dont C ++ gère les fonctions statiques, visitez: Les fonctions membres statiques en C ++ sont-elles copiées dans plusieurs unités de traduction?

Oui, vous pouvez définir des fonctions membres statiques dans le fichier * .cpp. Si vous le définissez dans l'en-tête, le compilateur le traitera par défaut comme en ligne. Cependant, cela ne signifie pas que des copies séparées de la fonction membre statique existeront dans l'exécutable. Veuillez suivre cet article pour en savoir plus à ce sujet: Les fonctions membres statiques en C ++ sont-elles copiées dans plusieurs unités de traduction?

Dans votre fichier d'en-tête, dites foo.h

class Foo{
    public:
        static void someFunction(params..);
    // other stuff
}

Dans votre fichier d'implémentation, dites foo.cpp

#include "foo.h"

void Foo::someFunction(params..){
    // Implementation of someFunction
}

Très important

Assurez-vous simplement de ne pas utiliser le mot-clé static dans la signature de votre méthode lorsque vous implémentez la fonction statique dans votre fichier d'implémentation.

Bonne chance

@crobar, vous avez raison de dire qu'il y a une pénurie d'exemples multi-fichiers, j'ai donc décidé de partager ce qui suit dans l'espoir que cela aide les autres:

::::::::::::::
main.cpp
::::::::::::::

#include <iostream>

#include "UseSomething.h"
#include "Something.h"

int main()
{
    UseSomething y;
    std::cout << y.getValue() << '\n';
}

::::::::::::::
Something.h
::::::::::::::

#ifndef SOMETHING_H_
#define SOMETHING_H_

class Something
{
private:
    static int s_value;
public:
    static int getValue() { return s_value; } // static member function
};
#endif

::::::::::::::
Something.cpp
::::::::::::::

#include "Something.h"

int Something::s_value = 1; // initializer

::::::::::::::
UseSomething.h
::::::::::::::

#ifndef USESOMETHING_H_
#define USESOMETHING_H_

class UseSomething
{
public:
    int getValue();
};

#endif

::::::::::::::
UseSomething.cpp
::::::::::::::

#include "UseSomething.h"
#include "Something.h"

int UseSomething::getValue()
{
    return(Something::getValue());
}

Sûr que vous pouvez. Je dirais que tu devrais.

Cet article peut être utile:
http://www.learncpp.com/cpp-tutorial/812-static-member-functions/

La #includedirective signifie littéralement "copier toutes les données de ce fichier à cet endroit". Ainsi, lorsque vous incluez le fichier d'en-tête, il est textuellement dans le fichier de code, et tout ce qu'il contient sera là, donner ou prendre l'effet d'autres directives ou remplacements de macro, lorsque le fichier de code (maintenant appelé unité de compilation ou unité de traduction ) est transféré du module préprocesseur au module du compilateur.

Ce qui signifie que la déclaration et la définition de votre fonction membre statique étaient vraiment dans le même fichier depuis le début ...