Ist es möglich, staticKlassenmitgliedsfunktionen in der * .cpp-Datei zu implementieren, anstatt dies in der Header-Datei zu tun?

Sind alle staticFunktionen immer inline?

Es ist.

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

Sie sind nicht immer inline, nein, aber der Compiler kann sie erstellen.

Versuche dies:

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

Weitere Informationen zum Umgang mit statischen Funktionen in c ++ finden Sie unter: Werden statische Elementfunktionen in c ++ in mehrere Übersetzungseinheiten kopiert?

Ja, Sie können statische Elementfunktionen in der * .cpp-Datei definieren. Wenn Sie es in der Kopfzeile definieren, behandelt der Compiler es standardmäßig als Inline. Dies bedeutet jedoch nicht, dass separate Kopien der statischen Elementfunktion in der ausführbaren Datei vorhanden sind. Bitte folgen Sie diesem Beitrag, um mehr darüber zu erfahren: Werden statische Elementfunktionen in C ++ in mehreren Übersetzungseinheiten kopiert?

Sagen Sie in Ihrer Header-Datei foo.h

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

Sagen Sie in Ihrer Implementierungsdatei foo.cpp

#include "foo.h"

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

Sehr wichtig

Stellen Sie nur sicher, dass Sie das statische Schlüsselwort nicht in Ihrer Methodensignatur verwenden, wenn Sie die statische Funktion in Ihrer Implementierungsdatei implementieren.

Viel Glück

@crobar, Sie haben Recht, dass es an Beispielen für mehrere Dateien mangelt. Deshalb habe ich beschlossen, Folgendes zu teilen, in der Hoffnung, dass es anderen hilft:

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

Sicher kannst du. Ich würde sagen, dass du solltest.

Dieser Artikel kann nützlich sein:
http://www.learncpp.com/cpp-tutorial/812-static-member-functions/

Die #includeDirektive bedeutet wörtlich "alle Daten in dieser Datei an diese Stelle kopieren". Wenn Sie also die Header-Datei einfügen, befindet sie sich in Textform in der Codedatei, und alles darin ist vorhanden, gibt oder nimmt die Wirkung anderer Anweisungen oder Makroersetzungen, wenn sich die Codedatei (jetzt als Kompilierungseinheit oder Übersetzungseinheit bezeichnet ) befindet vom Präprozessormodul an das Compilermodul übergeben.

Das heißt, die Deklaration und Definition Ihrer statischen Elementfunktion befanden sich die ganze Zeit über in derselben Datei ...