È possibile implementare staticle funzioni dei membri della classe nel file * .cpp invece di farlo nel file di intestazione?

Tutte le staticfunzioni sono sempre inline?

È.

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;
}

Non sono sempre in linea, no, ma il compilatore può crearli.

Prova questo:

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();
}

Per saperne di più su come c ++ gestisce le funzioni statiche, visitare: Le funzioni membro statiche in c ++ vengono copiate in più unità di traduzione?

Sì, puoi definire funzioni membro statiche nel file * .cpp. Se lo definisci nell'intestazione, il compilatore lo tratterà per impostazione predefinita come inline. Tuttavia, non significa che nell'eseguibile saranno presenti copie separate della funzione membro statica. Segui questo post per saperne di più: Le funzioni membro statiche in c ++ vengono copiate in più unità di traduzione?

Nel tuo file di intestazione dì foo.h

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

Nel tuo file di implementazione dì foo.cpp

#include "foo.h"

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

Molto importante

Assicurati solo di non utilizzare la parola chiave static nella firma del metodo quando stai implementando la funzione static nel tuo file di implementazione.

In bocca al lupo

@crobar, hai ragione sul fatto che mancano esempi di più file, quindi ho deciso di condividere quanto segue nella speranza che aiuti gli altri:

::::::::::::::
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());
}

Certo che puoi. Direi che dovresti.

Questo articolo può essere utile:
http://www.learncpp.com/cpp-tutorial/812-static-member-functions/

La #includedirettiva significa letteralmente "copia tutti i dati in quel file in questo punto". Quindi, quando includi il file di intestazione, è testualmente all'interno del file di codice e tutto ciò che contiene sarà lì, darà o avrà l'effetto di altre direttive o sostituzioni di macro, quando il file di codice (ora chiamato unità di compilazione o unità di traduzione ) è trasferito dal modulo del preprocessore al modulo del compilatore.

Il che significa che la dichiarazione e la definizione della tua funzione membro statica erano davvero nello stesso file da sempre ...