Tach!!

Ich hab da ein kleines Problem.
Hab nen vektor: short werte[52] = {0,0,3,5,......}; gebaut.
wenn ich jetzt ne if-Abfrage starte:
if(werte[0] == NULL)
{
printf("NULL");
}

dann geht er da rein, obwohl der doch auf ne 0 zeigt, nicht auf NULL.
Ich dachte immer NULL würde heißen, dass er ins Nirvana zeigt.
Oder hab ich jetzt was ganz falsch verstanden****?

Please help!!

ollek81

Im Prinzip ist das schon richtig, aber NULL ist einfach als 0x00000000h definiert, also quasi eine 32Bit-Null. Der Unterschied zwischen Deiner 0 und NULL ist also quasi gar keiner.

btw:

feld[] wäre ein Zeiger auf das erste Element des Feldes. Der kann nicht auf NULL zeigen, weil der Speicher für das Feld automatisch alloziert wird. feld[0] ist das erste Element des Feldes und wenn das 0 ist, dann ist es eben auch NULL, weil der Unterschied zwischen 0 und NULL eben auch Null ist (siehe oben).

Tja, sch....******!!

Und nu?
Hast du ne Idee, wie ich ne Bedingung hinbekomme, die guckt, ob der Zeiger auf ne Liste zeigt, oder nicht****
Im richtigen Programm werden die Werte aus ner externen Quelle eingelesen. Da kann der erste Wert schon mal 0 sein. Ist ja auch OK, muss halt nur ein Wert sein!!

Irgendeine Idee, wie das gehen könnte****

Danke schonmal für die klasse Erklärung!!

ollek81

Hmm...also mal angenommen die Werte aus der externen Quelle sind alle positiv. Dann initialisiert Du das Feld mit einem negativen Wert für das Element 0. Dann kannst Du nachher sehen, ob in das Feld was reingeschrieben wurde (dann müßte das erste Element ja >= 0 sein).

Hi!!

Gerade das ist ja das Problem! Die können auch negativ sein!

Hmm...beim Einlesen merkst Du doch aber, ob Werte kommen oder nicht. Dann kannst Du doch einfach 'ne Boole'sche Variable entsprechend belegen (TRUE für "da kam was", FALSE für "da kam nix") und die dann nachher auswerten. Wie wäre das?

EDIT: Da die Werte ja nur short seien können, mach einfach 'n int draus und beleg den ersten Wert meinetwegen mit 2^15 (32768). Das würde auch gehen (auch wenns mehr Speicher braucht, aber auf das knappe KByte kannste wohl verzichten )

Irgendwie kann ich das Problem nicht so ganz nachvollziehen. Wenn ich mit GCC den folgenden Code compilieren will, meckert der Compiler:

Code :

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h>                                                                                 int main(int argc, char **argv) {         short werte[5] = {0, 0, 3, 5, 1};         if(werte[0] == NULL)         {                 printf("NULL");         }         return 0; }

In der Zeile mit der Verzweigung bemängelt GCC nämlich, dass ich einen Integer-Wert mit einem Pointer vergleichen will...

Überseh ich da was?

Sorry, hätte doch etwas mehr schreiben sollen.

Ich muss ein paar Unterprogramme für ein Gesamtprogramm schreiben. Das Einlesen ist schon da, da kann ich also nix dran drehen.

(Bei der ganzen Sache geht's um "Spracherkennung". Das Prog soll z.B. den Vokal "a" erkennen.)

Ich bekomme nur einen Zeiger übergeben, der auf den Anfang der Abtastwerte zeigt. Wenn der nu "unterwegs" verschütt geht, oder sonst was nicht stimmt, soll ich das in meinem Unterprogramm erkennen und dann halt abbrechen.
Wenn alles in Ordnung ist geht's in die Auswertung...

So, ich hoffe, jetzt ist es etwas klarer, was ich will...

Schon mal danke für die Hilfe um diese Zeit******

ollek81

Das kommt drauf an, wie NULL definiert ist. Ich kann das kompilieren (VC6), weil für den Compiler wurscht ist, ob da NULL als null-pointer oder 0 gemeint ist bzw. NULL in zwei Varianten da ist (#define NULL 0 ist die, die der Compiler da oben nimmt)

Na wenn Du 'n Zeiger auf das Einleseergebnis bekommst, dann muß der Zeiger ja irgendwie initialisiert sein. Entweder isser NULL (also es wurde nix eingelesen) oder eben nicht. Dann kannst Du das ja vorher abfangen (wenn der abhanden kommt, is es doch eh Essig mit Deinem wert[...]). Jetzt müßte man natürlich noch wissen, ob der Zeiger tatsächlich initialisiert wird oder auch bloß auf'n Feld zeigt, was sowieso immer da is.

EDIT: Ich glaube, ich habs immer noch net gerafft.

@ Lirion

Mein Borland C 3.0 meckert auch nicht...

Eigentlich ist es bei mir ja auch ein "richtiger" Zeiger, der auf den Anfang zeigt. Aber mit dem einfachen Beispiel ging's leichter zu erklären und bei Borland machte das keinen Unterschied...

@ Vaethischist:

Ich weiß ja eben nicht, ob das initialisiert ist. Hab nur ein paar Infos, was meine Progs machen sollen, und deren Funktionsköpfe.

Selbst wenn er initialisiert wurde, leider springt er ja auch raus, wenn der erste Wert 0 ist****** Das ist das Problem!! Sonst würde das mit dem NULL ja klappen******!!

Ok...ich glaube, wir nähern uns langsam dem Kern der Sache.

Wenn Du den Zeiger auf das Feld mit den Werten bekommst, dann ist der auf jeden Fall initialisiert. Das Prob ist, was in dem Feld nun drinne steh.

Du hast ja einen definierten Wertebereich für das Wertefeld. Die sollen alle im short-bereich (also -2^15 bis 2^15-1) sein. Nehmen wir mal an, es ist was schief gegangen. Dann würde eines der Felder möglicherweise auf einen Wert zeigen, der nicht in diesem Wertebereich liegt. Soweit könnte man das ja austesten. Ein anderes Verfahren sehe ich da nicht...

Das klingt ja nicht schlecht. Werde das mal so machen. Wenn's dem Prof nicht passt, soll er halt sagen, wie er's will!!

Besten Dank und gute Nacht******!

Ollek81

In der Zeile mit der Verzweigung bemängelt GCC nämlich, dass ich einen Integer-Wert mit einem Pointer vergleichen will... Überseh ich da was?

Nein da übersiehtst du nix, denn der GCC ist gegenüber dem Visual C++ Compiler ein wenig penibler was solche Sachen angeht, ich will mal vorsichtig sagen, er ist etwas besser *g*.
Der Visual C++ Compiler verzeiht einem schon hier und da mal nen Fehler.

Gruss Homer, der das aus eigener Erfahrung kennt, wegen Windows/Unix Pralellentwicklung