int AnzahlR;
int AnzahlRL=1;
int R1;
cout << "wieviel Widerstände hat das Netzwerk?" << ends;
	cin >> AnzahlR;

Dann wird noch abgefragt wie groß und auf welche Art(in Reihe oder Parallel) der Widerstand eingebaut wurde:

while (AnzahlRL < AnzahlR+1)
	{
		cout << "Widerstand: " << AnzahlRL << ends;
		cin >> R1 >> Zustand;
		AnzahlRL = AnzahlRL++;

Da ja meistens unterschiedlich viel Widerstände im Netzwerk sind kann ich nicht im vorhinein die R1/2/3/... definiern. Wie schaffe ich es also ,dass wenn ich sage es sind z.B 8 Widerstände, dass ich 8 Speicherplätze für Wert und Art habe und ich diese später verrechnen kann? Könnte man das mit externen Textdateien oder Datenbanken machen? Dankeschön fürs lesen.

Bsp.
Widerstand 1 hat 350 Ohm und ist in Reihe.
Widerstand 2 hat 330 Ohm und ist in Reihe.
Widerstand 3 hat 450 Ohm und ist Parallel.
Also muss erkannt werden dass es sich um 3 Widerstände handelt und die zwei Werte müssen gespeichert werden. Das Reihe und Parallel wandle ich in bool um.
Das Rechnen ist kein Problem mehr... nur das Speichern und Abrufen?

#include <vector> //für den Datentyp 'vector' im Namensraum 'std'
#include <string> //für den Datentyp 'string' im selben.
#include <cstddef> //für den Datentyp 'size_t'
#include <iostream> //für das Objekt 'cout'. Auch in 'std' drin.

//zunächst eine kleine Aufzählung.
enum class WiderstandTyp { Parallel, Reihe };
//Hier wurde eine Aufzählung 'WiderstandTyp' deklariert.
//Variablen dieses Typs können entweder WiderstandTyp::Parallel
//oder WiderstandTyp::Reihe annehmen. Ist doch viel aussagekräftiger als
//ein bool, oder?

//nun eine kleine Struktur...
struct Widerstand
{
    //Wert
    unsigned int Ohm;

    //die Art des Einbaus:
    WiderstandTyp Typ;

    //...und einen Namen bekommt er auch noch:
    std::string Name;
};

int main()
{
    //Hier kommt std::vector ins spiel:
    std::vector<Widerstand> Widerstaende;
    //'Widerstaende' kann nun Objekte aufnehmen, die vom Typ 'Widerstand' sind.
    //Am Anfang ist dieser Container natürlich leer.

    //einen Widerstand anlegen...
    Widerstand einR;
    einR.Name = "R1";
    einR.Ohm = 470;
    einR.Typ = WiderstandTyp::Parallel; //befüllen.

    Widerstaende.push_back(einR); //und dazupacken.

    //zum durchiterieren bietet sich eine Schleife an:
    for(size_t idx = 0; idx < Widerstaende.size(); ++idx)
    {
    	std::cout << Widerstaende[idx].Name; //lässt sich prima wie ein Array ansprechen.
    }

}

struct widerstand
{
    int wert;
    bool parallelgeschaltet;
}

Sowas geht auch? Ich merke immer mehr wie sehr ich noch in C verhaftet bin.

Ja, ist das nicht schön?

Wo wir schon bei "schön" sind: ich habe ne Zeit lang mit Java gearbeitet und vermisse die Java-Style enums in C++ sehr. Die sind im Prinzip wie eine normale Klasse mit Membervariablen und Funktionen, wobei die Objekte alle schon direkt erzeugt werden (d.h. man gibt in dem enum jeweils den Konstruktor an). Außerdem kann ich da mit name bzw. valueOf gleich in/von String konvertieren.

In C++ ... gibt es da eigentlich irgendwas, um das einfach nachzubauen?