C++ Frage zum invertieren

[guest (Gast)]

Ich habe eine vorher eingegebene Subnetzmaske in 4 Oktets zerlegt und 
diese anschliessend durch eine Funktion in ihren Binärwert zerlegen 
lassen. Der Binärwert steht nun im Array Subnetz_okt1_bin. Dieses 
Binärarray soll invertiert werden. Leider klappt es mit

Subnetz_okt1_inv[i] = ~Subnetz_okt1_bin[i]

nicht. Ausgegeben wird danach für eine 11000000  ein 2-2-1-1-1-1-1-1
Ich habe mir jetzt erstmal mit einer If Abfrage geholfen. Aber gibt es 
da nicht einen eleganteren Weg?

    for(int i=0;i<8;i++) {
        if(Subnetz_okt1_bin[i] == 0) {
            Subnetz_okt1_inv[i] = 1;
        }
        else {
            Subnetz_okt1_inv[i] = 0;
        }
    }

[Klaus (Gast)]

Wozu das ganze zerlegen den Subnetzmaske? Lass die in einem Uint32 (32 
Bit breiter Integer) und schreib einfach

mask_inv = ~mask;

[guest (Gast)]

Ich will die IP und Subnetzmaske aber auch Binär ausgeben. Ausserdem 
brauche ich fürs Subnetting jedes Oktet einzeln.

[yalu (Gast)]

Der ~-Operator invertiert jedes einzelne Bit einer Integerzahl, d.h aus
1 wird -2

dezimal         binär
   1     ->     00000000000000000000000000000001
  -2     <-     11111111111111111111111111111110

und aus 0 wird -1

dezimal         binär
   0     ->     00000000000000000000000000000000
  -1     <-     11111111111111111111111111111111

Du kannst, wie von Klaus vorgschlagen, diese Operation auf die komplette
Maske anwenden, wenn diese als 32-Bit-Integerzahl vorliegt, was in
diesem Fall das Einfachste ist.

Möchtest du hingegen eine 1 in eine 0 und eine 0 in eine 1 umwandeln,
nimmst du den !-Operator:

Subnetz_okt1_inv[i] = !Subnetz_okt1_bin[i]

[guest (Gast)]

Möchtest du hingegen eine 1 in eine 0 und eine 0 in eine 1 umwandeln,
nimmst du den !-Operator:

Subnetz_okt1_inv[i] = !Subnetz_okt1_bin[i]

Das tuts, danke!

[Vlad T. (vlad_tepesch)]

dass nenn ich mal effizient.
jedes Bit in ein char (oder gar int?) zu schmeißen.

Warum hörst du nicht auf Klaus und packst das in ein uint32_t?

die Anzeige kann ja nicht der Grund für die Speicherverschwendung sein.

das kannm an dann ja genauso mit einer schleife binär anzeigen:

uint32_t mySubNetMask = 0xabcdefab;
std::cout << "Mask: dez: << ((mySubNetMask >>24) & 0xff) <<"."
                         << ((mySubNetMask >>16) & 0xff) <<"."
                         << ((mySubNetMask >>8 ) & 0xff) <<"."
                         << ((mySubNetMask     ) & 0xff) <<std::endl
          << "      hex: 0x << hex <<mySubNetMask <<std::endl
          << "      bin: "

uint32_t tempSubNetMask = mySubNetMask ;
for( uint8_t i = 0; i<32; ++i)
{
  std::cout << (tempSubNetMask & 0x80000000U):'1':'0'; // testet oberstes bit
  tempSubNetMask <<= 1; // alle bits eins hoch schieben.
}
std::cout << "b" << std::endl;

[Karl H. (kbuchegg)]

Vlad Tepesch schrieb:
> dass nenn ich mal effizient.
> jedes Bit in ein char (oder gar int?) zu schmeißen.

Ich wage mir gar nicht auszudenken, wie sich diese Aufdröselung bei der 
weiteren Verarbeitung der IP auswirkt.

Da wird wieder mal die interne Speicherung von den Bedürfnissen der 
Ausgabe bestimmt, anstatt sich eine schöne Ausgabefunktion zu bauen, die 
eine naheliegende Standardspeicherung so aufbereitet, wie man das haben 
möchte.

[guest (Gast)]

na immer eins nach dem anderen.
erst mal stehe ich noch am anfang und da hat es für mich zu allererst 
priorität das ich mein ziel überhaupt erreiche. hinzu kommt das ich fürs 
subnetting doch immer nur die oktets untereinander logisch und bzw 
logisch oder verknüpfen muss. davon ab kann man es mit der effizienz 
auch übertreiben. das programm ist immerhin für den rechner und läuft 
nicht auf einem uC. wenn ich da fürs ausführen des programms zwei oder 
drei dutzend bytes speicher in beschlag nehme ist es zwar immer noch 
schlampig, aber kaum der rede wert.

[Peter (Gast)]

>  hinzu kommt das ich fürs
> subnetting doch immer nur die oktets untereinander logisch und bzw
> logisch oder verknüpfen muss.

wie kommst du darauf?


was ist wenn du mal die Subnetzadresse 255.255.255.192 (/26) hast?
Subnetzte müssen nicht an Oktets ausgerichtet sein!.

[Karl H. (kbuchegg)]

guest schrieb:
> na immer eins nach dem anderen.
> erst mal stehe ich noch am anfang und da hat es für mich zu allererst
> priorität das ich mein ziel überhaupt erreiche.

Klar.
Mann kann auch über Prag von Berlin nach Hamburg fahren.
Hauptsache man kommt an :-)

> drei dutzend bytes speicher in beschlag nehme ist es zwar immer noch
> schlampig, aber kaum der rede wert.

Du schaffst dir selber eine Menge mehr Arbeit als eigentlich notwendig, 
nur damit du an einer anderen Stelle (Ausgabe) vergleichsweise wenig 
Arbeit hast.

Es stimmt schon: vorzeitige Optimierung ist die Wurzel allen Übels.
Aber auf der anderen Seite sehen wir hier jeden Tag wie sich ein 
Programmierer selbst ein Bein stellt, indem sich ein vermeintlich 
cleverer Hack an einer Stelle an hundert anderen Stellen ins genaue 
Gegenteil verkehrt.

Was du dir merken solltest: Wenn du eine bestimmte Ausgabe haben willst, 
dann ist es fast immer unklug, die interne Speicherung von dieser 
Ausgabe bestimmen zu lassen. Das sieht bei den ersten Schritten sehr 
verführerisch aus. Aber auch nur deshalb weil die ersten Schritte 
praktisch immer sich nur um Eingabe bzw. Ausgabe drehen. Sobald du dann 
anfängst mit den Werten im Programm zu arbeiten, dreht sich der 
vermeintliche Vorteil meistens sehr schnell ins Gegenteil um. Und dann 
muss man soweit sein, einen Schritt zurückzutreten, sich anzusehen, wie 
man sich das Leben in der Verarbeitung einfacher machen kann und die 
Ausgabefunktionen daran anpassen. Und oft genug stellt man dann fest, 
dass plötzlich ein durchaus erklecklicher Anteil Code einfach wegfällt. 
Der Code wird einfacher, logischer, besser durchschaubar, wartbarer und 
enthält weniger Fehler.

Gerade bei Neulingen machen erfahrene Programmierer immer wieder 
dieselbe Beobachtung: sie kleben an bereits geschriebenem Code fest, als 
wäre der von Moses persönlich in Stein gemeisselt worden.