Ich komme einfach nicht dahinter... ...ich verstehe nicht warum
PreInitData.data, welche in B.cpp als Parameter an den Konstruktor
von p übergeben wird, dort nicht bereits mit 100.0 initialisiert ist?

Wäre toll wenn mir das jemand erklären könnte, danke!

// Datei A.h

#pragma once

template <class T> class A {
  public :

  T data;  

  static const A<T> PreInitData;

  A(T x);
};

template <class T> const A<T> A<T>::PreInitData(100.0);

template <class T> A<T>::A(T x) {
  data= x;
}

// Datei A.cpp (leer)

#include "A.h"

// Datei B.h

#pragma once

#include "A.h"

class B {
  static A<float> p;
};

// Datei B.cpp

#include "B.h"

A<float> B::p(A<float>::PreInitData.data);

Der Code in B.cpp läuft in 2), der Code in A.h läuft in 3). Also ist klar was passiert.
Dass in Phase 2) ein Wert verwendet wird der in Phase 3) geändert wird ist "schlecht", aber AFAIK erlaubt, und das Ergebnis wäre laut Standard IMO falsch wenn es anders wäre (also nicht 0).

Die richtige Reihenfolge bei der Initialisierung zu erzwingen ist ein altbekanntes Problem in C++. Ohne eine mir bekannte Lösung die sich überall schön anwenden liesse. Allerdings lässt sich natürlich immer irgendwie (mehr oder weniger schön) herumbauen.

Dass in Phase 2) ein Wert verwendet wird der in Phase 3) geändert wird ist "schlecht", aber AFAIK erlaubt, und das Ergebnis wäre laut Standard IMO falsch wenn es anders wäre (also nicht 0).

Der Standard erlaubt es ausdrücklich, die Initialisierung von A<float>::PreInitData.data als statische Initialisierung durchzuführen. Es ist somit unspezifiziert, ob B::p mit 0 oder 100 initialisiert wird.

// Datei A.h

#pragma once

template <class T> class A {
  public :

  T data;  

  static const A<T>& getPreInitData();

  A(T x);
};

template <class T> const A<T>& A<T>::getPreInitData()
{
  static const A<T> preInitData(100.0);
  return preInitData;
}

template <class T> A<T>::A(T x) {
  data= x;
}

Jetzt müsste beim ersten Aufruf von getPreInitData() doch auf jeden Fall preInitData initalisiert werden oder nicht?
@OP: was willst du überhaupt damit erreichen? das sieht mir ein wenig nach Singleton-Pattern aus, nur dass du den Ctor und auch die Attribute (!) sämtlich public gemacht hast (was bei Attributen in 99,9% der Fälle schlecht ist, wenns nicht grade um einfache Datenbündel-Structs geht)

Warum läuft denn der Code in A.h in 3) dynamic-initialization?
Mit dynamisch ist doch zur Laufzeit gemeint? Sorry wenn die
Frage doof ist

template <class T> const A<T> A<T>::PreInitData= 100.0;

...d.h. für die initialisierung nicht den selbst
deklarierten Konstruktor verwende, bekomm ich in
B.cpp immernoch ne 0.0 statt 100.0.

Dabei müßte doch jetzt alles auf statischer Ebene ablaufen?

Und A<T> ist wie camper schon schreibt kein POD und wird dauer auch nicht statisch initialisiert, sondern dynamisch, und zwar indem der Konstruktor aufgerufen wird.

BTW: ich finde es ziemlich grausig wenn eine Klasse ein statisches Member des eigenen Typs hat. Und WENN man sowas schon machen muss, dann wäre ein besserer Name als "PreInitData" sicher hilfreich.

Also nochmal konkret: A<float>::PreInitData und B::p sind beides Instanzen von A<float> und werden daher beide dynamisch initialisiert (nach der zero-initialization natürlich). Ob nun aber A<float>::PreInitData oder B::p zuerst drankommt ist purer Zufall, da die Reihenfolge nicht definiert ist.

Und ich hoffe nicht schonwieder etwas übersehen zu haben.

Deine Lösung funktioniert! Danke!
Aber warum funktioniert das?

Aber warum funktioniert das?

Weil die statische Variable innerhalb der Funktion auf jeden Fall initialisiert wird, sobald die Funktion das erste Mal aufgerufen wird.
Ich überlasse das jetzt mal den Profis, festzustellen in welcher der init-phasen das jetzt genau stattfindet, es funktioniert auf jeden Fall so gut wie immer.

Was nicht funktionieren kann ist natürlich wenn sich zwei Initialisierungsroutinen für statische Funktionsmember gegenseitig aufrufen, etwa folgender Art:

struct Foo {
  static int get();
};

struct Bar {
  static int get()
  {
    const static int i = Foo::get();
    return i;
  }
};

int Foo::get()
{
  const static int f = Bar::get();
  return f;
}

Aber kein halbwegs vernünftiger Entwickler würde solche Kreisabhängigkeiten produzieren