Ich benötige mindestens ein A um einen Algorithmus durchzuführen.
Jede Klasse wird aus einer Textdatei eingelesen.

Wie erzeuge ich nun die Objekte am besten. Ich schreibs mal besser in Pseudo-C++ auf.

class A
{
  notwendige Attribute, die mein Programm braucht
}

class B : A
{
  ein paar Attribute mehr
}

main()
{
  A* hiermit_will_ich_arbeiten;
  // Wie fülle ich das auf, wenn Dateizugriffe nötig sind?
}

//Idee 1: Methode
A* readFile(filename)
{
entscheide anhand dateieindung was genau zu tun ist.
A* r = new Was_benötigt_wird();
return r;

//gefällt mir nicht, weil das new versteckt wird
}

//Idee 2: Konstruktor erledigt das
class C: A
{
C(filename)
{lese datei aus}
} 
}

Vor einem ähnlichen Problem stehe ich auch beim Zurückschreiben der Datenstrukturen.
Gibt es da schöne ANsätze?

class A
{
};

class B : public A
{
};

std::vector<std::unique_ptr<A>> readAs(const std::string& filename)
{
  std::vector<std::unique_ptr<A>> as;
  // ..
  as.push_back(std::unique_ptr<A>(new A)); // Eventuell bastelst du dir ein make_unique().
  // ..
  return as;
}

int main()
{
  auto as = readAs("as.txt");
  for (auto i = begin(as); i != end(as); ++i)
    std::cout << **i; // Setzt überladenen operator << für A voraus.
} // Destruktor von vector zerstört seine unique_ptr, deren Destruktoren zerstören die As.

Und vergiss den virtuellen Destruktor für A nicht.

Herauszufinden, um was für ein Typ es sich handelt ist normalerweise ein Zeichen dafür, dass das Design nicht gut ist. Lösen kann man das häufig dadurch, dass die Klasse selber die Methode implementiert und diese nur aufgerufen wird. Die Klasse weiß dann selber was zu tun ist.

Manager.loadFile("bla.xyz");

Das Ergebnis ist dann ein File * (dazu jetzt mehr). Die Klassenhierachie kann dann in etwa so aufgebaut werden, wie du es schon angedacht hast. Damit das funktioniert (und Sinn macht) müssen natürlich alle Dateiformate etwas gemeinsam haben. Bei Bildern wären das z.B. die Pixel die am Ende angezeigt werden können.

Könnte man dann so lösen:

class File
{
 Pixel *pixel;

 virtual void load() = 0;

 virtual Pixel *getPixel() { return pixel; }
};

class FileXYZ : public File
{
 virtual void load() { doMagic(); }
};

Dann kann loadFile entweder das File * zurückgeben oder es verwaltet diese und du greifst über den []-Operatoren darauf zu:

Manager["bla.xyz"].getPixel();

Dann gibt manager auch den Speicher frei oder man gibt den Speicher vorzeitig manuell frei:

Manager.unloadFile("bla.xyz");

Letztendlich ist das aber nur eine von vielen Möglichkeiten. Ich bin was das angeht auch kein Experte und tue mich da immer etwas schwer. Mir würde in dem Zusammenhang noch das Strategy Pattern einfallen. Leider ist die Entscheidung, wie man vorgehen sollte oft von vielen Faktoren abhängig, die den Leuten hier nicht alle bekannt sein können.

Ich stelle mir das grad irgendwie so vor:

std::unique_pointer<A> readFile(filename)
{ 
  // entscheide welcher Typ
  Typ * b = new Typ;
  std::unique_pointer<A> p(b);

  // kann ich das so zurückgeben?
  return p;
}

main()
{
  // völlig blind geraten
  std::unique_pointer<A> a = std::move(readFile(filename));
 // unique_pointer können ja nicht kopiert werde, also müsste ich moven, aber keine AHnung ob das so stimmt
 // gerade mal 10 Minuten google stecken jetzt dahinter und ich finde keine richtig gute Quelle
}

Also , ich begebe mich hier auf völliges Neuland, aber bin bereit mich einzuarbeiten.
Wenn ihr Tipps dafür habt oder schonmal Korrekturvorschläge für meinen wahrscheinlichen Quatsch oben, ich bitte darum.

Gute Quellen sind auch immer willkommen.

Wenn ihr Tipps dafür habt oder schonmal Korrekturvorschläge für meinen wahrscheinlichen Quatsch oben, ich bitte darum.

Das ist grundsätzlich schon ok. Nur dass du keinen extra Zeiger einführen solltest, unique_ptr<A>(new A) reicht völlig. Und genau, du gibst ihn einfach per value zurück. std::move brauchst du nicht. Weder bei return, noch in der main. (Warum schreibst du eigentlich kein int vor die main? oO)
std::move ist wie ein Cast, und sollte auch nur so verwendet werden:

foo(unique_ptr<A>(new A)); // Kein move

unique_ptr<A> p(new A);
return p; // kein move

unique_ptr<A> = bar(); // kein move

unique_ptr<A> p(new A);
foo(move(p)); // move, da nicht klar ist, dass du das auch wirklich möchtest.

Ansonsten zur "Allgemeinbildung" nach "Move-Konstruktoren" suchen, die sind quasi die Basis des unique_ptr.