He Leute,

nochma ne Frage xD

Wann benutz ich static, bzw. welchen Sinn hat es?

Kann mir da einer von euch Freaks weiterhelfen ich find kein gescheites tut und die Hilfe is diesmal extrem blöd ^^


Gruß, Seb

Wenns was mit Javaprogrammierung zu tun hat, dann sind static-methoden Klassenmethoden, die für die gesamte Klasse gelten und nicht nur für ein instanziiertes Objekt.

No, bis dato weiss ich nur, dass man static dazu nutzt, Methoden ( die natürlich static sind ) aufzurufen, ohne ein Objekt der Klasse erstellt zu haben. Nützlich z.B bei ner Methode getShicehaufen - die gibt mir dann die Anzahl der Shicehaufen in irgendwas....Aber hat static auch noch ne höherliegende Bedeutung, nutz ich das nur in solchen fällen - wofür brauch ich static variablen -.- `?

In der std Hilfe ist geschrieben, das die static Variable durch das komplette Programm existiert..

C++ Syntax:


Bsp.:

Ich erstelle eine Klasse "cPrinter". Hier lese ich im Konstruktor alle Drucker ein, die ich initialisiert im System liegen habe.
Die Klasse besitzt folgende Methoden:
PrintStd(char* x), // druck auf den zuletzt gewaehlten Drucker.....

Wenn ich also, irgendwo im Code die Stelle habe, indem ich etwas drucken möchte, so soll es so aussehen:

cPrinter prt;
prt.PrintStd("Blahfasel");

Ohne Static deklaration müsste ich jedesmal alle installierten Drucker neu initialisieren und den Standarddrucker neu auswählen.

Die Klasse könnte so aussehen:

class cPrinter
{
public
static int m_StandardDrucker;
static CDruckerliste m_Druckerliste;

cPrinter();
void PrintStd(char* text);
};

// Da die Variablen Static sind und die Klasse noch keinen Speicherraum zugewiesen
// bekommt, muessen die Static Variablen "Ausserhalb" deklariert werden!

int cPrinter::m_StandardDrucker = -1;
CDruckerliste cPrinter::m_Druckerliste;

Sobald der Konstruktor alle Drucker einmal eingelesen hat, kann man implementieren, das solange die Druckerliste nicht leer ist, er keine neuen Drucker einlesen soll. Nach dem das erste mal PrintStd aufgerufen wird, speichert sich der PrintStd den aktuellen Drucker, den der Benutzer ausgewählt hatte. Somit kommt die Abfrage ebenfalls nicht mehr....


gruss
Ralf

D.h static variablen sind global und behalten ihren Wert während der runtime - also im gegensatz zu dynamischen vars ändert sich der wert nicht - vergleichbar mit nem define?

Nein, kein define

define ...

ist in etwa wie:

const .... = ....;

Beim define aendert sich der Wert nicht mehr, bzw. "define" ist eine Kompileranweisung, die dem Kompiler sagt, was er dort einsetzen soll. "const ..." wird wirklich wie eine Variable behandet, allerdings aendert sich der Wert nicht!!.


static bedeuted, das immer, wenn du auf die variable zugreifen wirst, auf die selbe Speicheradresse zugreifst. Static ist zu vergleichen mit der von dir erwaehnten globalen variable...

D.h. in einer Klasse eine static Variable zu definieren bedeutet, das alle Instanzen dieser Klasse auf die "selbe" Variable zugreifen (der selbe Speicherplatz).

gruss
Ralf

Alles klar, ich danke dir ....

Aber wahrscheinlich kommt eh nur Server-Client und Bitoperationen dran...is halt nice to know...

So far, ich lern ma noch ne Runde Mathe ...

Zu Bitoperationen - wir sollen evtl. n kleinen Code schreiben, der überprüft, welche Bits einer festgelegten Zahl gesetzt sind. Sollte so gehen oder? Also es soll immer nur 1 Bit überprüft werden:

using System;
using System.Collections.Generic;
using System.Text;

namespace Bitverschiebung
{
class Program
{
static void Main(string[] args)
{
byte generatetNumber=165; // Bitfolge = 10100101 => 2^0+2^2+2^5+2^7=165
int vergleichswert =0;

Console.WriteLine("Generierter Wert: " + generatetNumber);
Console.WriteLine("Bitfolge: 10100101");
Console.WriteLine("Bit eingeben, das auf Status überprüft werden soll: ");

string eingabe = Console.ReadLine();


switch (eingabe)
{
case "1": vergleichswert = 1; Console.WriteLine("00000001"); break; // Bitfolge = 00100000 => 2^5= 32
case "2": vergleichswert = 2; Console.WriteLine("00000010"); break; // Bitfolge = 00100000 => 2^5= 32
case "3": vergleichswert = 4; Console.WriteLine("00000100");break; // Bitfolge = 00100000 => 2^5= 32
case "4": vergleichswert = 8; Console.WriteLine("00001000"); break; // Bitfolge = 00100000 => 2^5= 32
case "5": vergleichswert = 16; Console.WriteLine("00010000");break; // Bitfolge = 00100000 => 2^5= 32
case "6": vergleichswert = 32; Console.WriteLine("00100000");break; // Bitfolge = 00100000 => 2^5= 32
case "7": vergleichswert = 64; Console.WriteLine("01000000");break; // Bitfolge = 00100000 => 2^5= 32
case "8": vergleichswert = 128; Console.WriteLine("10000000");break; // Bitfolge = 00100000 => 2^5= 32
default: Console.WriteLine("Wie wärs mit ner gescheiten Zahl du Affe?"); break;
}

//vergleichswert = vergleichswert >> 7; //allgemeiner vergleichswert, mit dem ich je nach aufgabenstellung schiebe
Console.WriteLine("Vergleich: " + vergleichswert);
if ((generatetNumber & vergleichswert) == 0)
Console.WriteLine("Bit nicht gesetzt");
else
Console.WriteLine("Bit gesetzt");
}
}
}

Ignorier die COmments in der Switch das war copy+paste [img]icon_razz.gif[/img]

Kannst du so programmieren.



Vielleicht folgendes noch:

Deine Eingabe:

string eingabe = Console.ReadLine();

kannst du dann aendern in eine Zahl.

int x = atol(eingabe) // Konvertierung in ein Zahl
if(x > 0)
{
vergleichswert = pow(2,(x-1)) // Direkt 2^(x-1) umrechnen
}
else
{
// Gescheiten Bitvergleichswert eingeben!!!!
}

if(vergleichswert&generatetNumber)
// Die If Abfrage einfacher gestaltet....
// Muss ja nur true sein!
{
//Bit gesetzt.
}
else
{
// Bit nicht gesetzt.
}

Deine Abfrage ist optisch nicht so schoen, da alles Abfrage auf 0 mit ! (not) beantwortet werden koennen.
Die If Abfrage ist immer erfolgreich, wenn der Term true ist, allso alles ungleich 0.

if ((generatetNumber & vergleichswert) == 0) -> if(!(generatetNumber & vergleichswert))
Da du eine "Else"-klausel dabei hast, ist es besser, die Abfrage umzudrehen.. Die Else klausel zuerst, also nicht auf 0 abfragen, sondern umgekehrt: if(vergleichswert&generatetNumber) .....









Damit kannst du das hier sparen und bist flexibler, da du auch auf bit20 ueberpruefen kannst!:
<span style="font-size:7pt">
switch (eingabe)
{
case "1": vergleichswert = 1; Console.WriteLine("00000001"); break; // Bitfolge = 00100000 => 2^5= 32
case "2": vergleichswert = 2; Console.WriteLine("00000010"); break; // Bitfolge = 00100000 => 2^5= 32
case "3": vergleichswert = 4; Console.WriteLine("00000100");break; // Bitfolge = 00100000 => 2^5= 32
case "4": vergleichswert = 8; Console.WriteLine("00001000"); break; // Bitfolge = 00100000 => 2^5= 32
case "5": vergleichswert = 16; Console.WriteLine("00010000");break; // Bitfolge = 00100000 => 2^5= 32
case "6": vergleichswert = 32; Console.WriteLine("00100000");break; // Bitfolge = 00100000 => 2^5= 32
case "7": vergleichswert = 64; Console.WriteLine("01000000");break; // Bitfolge = 00100000 => 2^5= 32
case "8": vergleichswert = 128; Console.WriteLine("10000000");break; // Bitfolge = 00100000 => 2^5= 32
default: Console.WriteLine("Wie wärs mit ner gescheiten Zahl du Affe?"); break;
}
</span>

Wenn du rumspielen moechtest, kannst du deinen "generatetNumber" auch einlesen lassen
und bitweise ausgeben:

for(int x = 1;x < generatetNumber;x = x<<1) printf("%d",x&generatetNumber?1:0);

So kannst du auch alle Zahlen direkt bitweise ausgeben....



Ich habe es allerdings nicht in C# getestet.....

gruss
Ralf

Jo, ich habs halt so gemacht, wie ichs von C++ kenn, wir sollen nur die ersten 8 Bits überprüfen, deswegen die switch....hast zufällig n Algorithmus da, mit dem ich auch mehrere Prüfen kann? also z.B 1 und 4 und 7 etc...

Ich hab mir überlegt, man könnte die Eingabe so gestalten, dass man einfach maximal 8 zahlen hintereinander eingibt, wenn man calculate eingibt, wird die eingabe abgebrochen, ansonsten kann man eben die vollen 8 Bits mit 256, bzw. 255 am Ende abfragen.

Nun würd ich machen:

Vergleichszahl = 2^(Eingabe-1)+2^(Eingabe2-1)..............

dann müsste man natürlich 8-(Anzahl der Eingaben) und das Ergebnis davon von de Vergleichszahl abziehen um die ^0 Werte, die ja 1 ergeben, zu eliminieren...dann hätte ich das doch.,...is halt absolut umständlich und geht mit sicherheut einfacher -.- nur komm ich nich drauf

// Bitvergleich von 2 Zahlen, die eingegeben wurden.....

void DruckeZahlaus(int value)
{

int exp = 1;
for(int x = 1;x <= value;x = x<<1,exp = exp*2);

for(int x = exp>>1;x > 0;x = x>>1)
printf("%d",x&value?1:0);

}


int _tmain(int argc, _TCHAR* argv[])
{
int value = 165;

char zahl1;
char zahl2;


gets(zahl1);
gets(zahl2);

printf("\nZahl1 sieht wie folgt aus:");
DruckeZahlaus(atol(zahl1));
printf("\nZahl2 sieht wie folgt aus:");
DruckeZahlaus(atol(zahl2));

printf("\n der direkte Vergleich gibt folgendes:");
int ergebnis = atoi(zahl1)&atoi(zahl2);
DruckeZahlaus(ergebnis);

for(int cnt = 1,int x = 1;x <= ergebnis;x = x<<1,cnt++)
{
if(x&ergebnis)
{
printf("\nBit Nummer:%d ist gesetzt",cnt);
}
}
getchar();

return 0;
}





// Wenn du das einlesen aendern moechtest, dann koenntest du folgendes machen:

// Stelle der Bitmarkierung einlesen: 4 -> 2^(4-1) -> 8. Dieses Bit natuerlich mit deinem
// generatedNumber verodern!

printf("bitte geben Sie solange bitstellen ein, bis sie mit -1 aufhoeren moechten").

int zahl = 0;
generatedNumber = 0;
while(zahl>= 0)
{
printf("\nZahl eingeben: (-1) zum beenden: ");
char str;
gets(str);
zahl = atol(zahl);
if(zahl > 0)
{
generatedNumber |= pow(2,zahl-1);
}
}

Waahh ich kopier mir das nu erstma ins Studio und rück das ein, das Forum zerstört die gute formatierung...kann man ja nix lesen so

Aber danke schonmal