[C] 3egraads pointer initialisatie

[Verwijderd]

Ik wil dus een pointer initialiseren. Met normale pointers is dit niet zo'n probleem:

code:

const gchar *blaat = "bla";

Ook pointers-pointers lukt nog:

code:

const gchar *hz_list[] =        { "11025",
                        "22050",
                        "44100",
                        "48000",
                        NULL };

Maar als ik daar een pointer-pointer-pointer van wil maken, dan werkt dat niet:

code:

const gchar *audio_encoders[][] = {
                        { "MPEG-1 layer 3",
                          "Raw PCM WAV",
                          NULL },
                        { "Raw PCM WAV",
                          NULL },
                        { "MPEG-1 layer 1",
                          "MPEG-1 layer 2",
                          "MPEG-1 layer 3",
                          NULL },
                        { "Ogg Vorbis",
                          NULL },
                        { "MPEG-1 layer 1",
                          "MPEG-1 layer 2",
                          "MPEG-1 layer 3",
                          NULL },
                        { "Raw PCM WAV",
                          NULL },
                        NULL
                        };

Waarom niet En hoe krijg ik dit werkend

(Overigens: als ik *audio_encoders[][] in *audio_encoders[][4] verander, werkt het wel, maar da's niet echt waar ik naartoe wil )

[edit]
compiler-output geven is wel handig

code:

elements of array `audio_encoders' have incomplete type
warning: excess elements in array initializer
warning: (near initialization for `audio_encoders[2]')
warning: excess elements in array initializer
warning: (near initialization for `audio_encoders[4]')

Compiler: gcc, OS: linux-2.4.17, glibc: 2.2

[Orphix]

Ik denk dat het probleem is dat je in de ene array 4 waarden en in de andere array 2 waardes wilt stoppen. Probeer die van 2 eens aan te vullen met NULL's.

[Verwijderd]

Dan kom ik van de warnings af, maar de melding

code:

elements of array `audio_encoders' have incomplete type

blijft dan staan, en dus compileert ie nog steeds niet

[Verwijderd]

Het probleem van *audio_encoders[][4] is het volgende:

code:

#include <stdlib.h>
#include <stdio.h>

const char *audio_encoders[][4] = {
                        { "MPEG-1 layer 3",
                          "Raw PCM WAV",
                          NULL,
                          NULL },
                        { "Raw PCM WAV",
                          NULL },
                        { "MPEG-1 layer 1",
                          "MPEG-1 layer 2",
                          "MPEG-1 layer 3",
                          NULL },
                        { "Ogg Vorbis",
                          NULL },
                        { "MPEG-1 layer 1",
                          "MPEG-1 layer 2",
                          "MPEG-1 layer 3",
                          NULL },
                        { "Raw PCM WAV",
                          NULL },
                        NULL
                        };

int main()
{
  int i, j;

  for (i=0;audio_encoders[i]!=NULL;i++)
  {
    for (j=0;audio_encoders[i][j]!=NULL;j++)
    printf("%d/%d: %s\n",
      i, j, audio_encoders[i][j]);
  }

  return 0;
}

Geeft:

code:

[15 Feb - rbultje@tux /tmp]# ./test
0/0: MPEG-1 layer 3
0/1: Raw PCM WAV
1/0: Raw PCM WAV
2/0: MPEG-1 layer 1
2/1: MPEG-1 layer 2
2/2: MPEG-1 layer 3
3/0: Ogg Vorbis
4/0: MPEG-1 layer 1
4/1: MPEG-1 layer 2
4/2: MPEG-1 layer 3
5/0: Raw PCM WAV
9/0: UåWVSì
         è¢ûÿÿÃÞ]
9/1: h
9/2: UåWVSì
         èîÿÿÿ
9/3: UåSèðÿÿÿÃ,b

9/4: h
10/0: h
Segmentation fault (core dumped)
[15 Feb - rbultje@tux /tmp]#

En die NULL staat er dus juist in om als terminator te dienen, en dat werkt dan dus niet

[.oisyn]

dat komt omdat je de array moet initialiseren met pointers naar pointers, en niet met een array met pointers

Dit werkt bijvoorbeeld wel:

code:

const char *subarray1[] = { "hallo", "doei" };
const char *subarray2[] = { "blaat", "en weer wat", "ik weet niets meer" };

const char *array[][] = { subarray1, subarray2 };

even ter verduidelijking, een string tussen quotes is in principe een pointer naar char, waarbij de chars in een apart stukje geheugen worden gezet

als je een array declareert met { } dan worden de elementen daarvan in die array gezet, en het is dus geen pointer naar een stukje geheugen waar die elementen staan

daarom kan dit ook niet:

code:

int * i = { 1, 2, 3, 4 };

[Verwijderd]

Eienlijk vind ik dat niet echt mooi, maar ik vrees dat je gelijk hebt, dat is de enige oplossing....

Bedankt, weer wat geleerd

[Killemov]

Misschien heb je wel iets aan:

code:

const char ***audio_encoders

[.oisyn]

Op zaterdag 16 februari 2002 01:56 schreef Killemov het volgende:
Misschien heb je wel iets aan:

code:

const char ***audio_encoders

nee, want char ***var is gelijk aan char *var[][]

[Soultaker]

Het voorstel met het type 'char * [][4]' kan je wel werkend krijgen door in de laatste regel niet 'NULL' maar '{NULL}' op te nemen en in de for-lus te checken op 'audio_encoders[i][0]!=NULL'. Je hoeft dan verder niet aan te vullen met NULL'en.

Dit is natuurlijk nog steeds niet de meest ideale situatie, maar waarschijnlijk wel verkieslijker dan het afzonderlijke declareren van alle subarrays.

[farlane]

Als je voor je records eens structs definieert?

[Verwijderd]

Op zaterdag 16 februari 2002 20:21 schreef Soultaker het volgende:
Het voorstel met het type 'char * [][4]' kan je wel werkend krijgen door in de laatste regel niet 'NULL' maar '{NULL}' op te nemen en in de for-lus te checken op 'audio_encoders[i][0]!=NULL'. Je hoeft dan verder niet aan te vullen met NULL'en.

Dit is natuurlijk nog steeds niet de meest ideale situatie, maar waarschijnlijk wel verkieslijker dan het afzonderlijke declareren van alle subarrays.

Ik zou liever op NULL in audio_encoders[i] checken.... maargoed, dit werkt ook wel... Niet echt ideaal, maar hier bestaat blijkbaar geen ideale oplossing voor

[.oisyn]

wat je ook kunt doen is gebruik maken van een 1-dimensionale array. 1 NULL is dan om aan te geven dat de huidige sub-array eindigt, en 2 NULL'en achter elkaar om aan te geven dat de array eindigt

zoiets dus:

code:

const gchar *audio_encoders[] =
{
      "MPEG-1 layer 3",
      "Raw PCM WAV",
    NULL,
      "Raw PCM WAV",
    NULL,
      "MPEG-1 layer 1",
      "MPEG-1 layer 2",
      "MPEG-1 layer 3",
    NULL,
      "Ogg Vorbis",
    NULL,
      "MPEG-1 layer 1",
      "MPEG-1 layer 2",
      "MPEG-1 layer 3",
    NULL,
      "Raw PCM WAV",
    NULL,
    NULL
};

[Soultaker]

Op zondag 17 februari 2002 17:09 schreef OiSyN het volgende:
wat je ook kunt doen is gebruik maken van een 1-dimensionale array. 1 NULL is dan om aan te geven dat de huidige sub-array eindigt, en 2 NULL'en achter elkaar om aan te geven dat de array eindigt

Dat is eigenlijk nog wel de mooiste, aangezien je dan ook geen geheugen 'verspilt'. Een klein nadeel is wel, dat je de subarrays niet meer aan de hand van een index kunt ophalen. Je zal dus de hele array moeten doorlopen om het gewenste item te vinden. Intern kun je natuurlijk de pointer naar het eerste element van een subarray gebruiken, zodra je de goede subarray gevonden hebt.

Een ander nadeel is dat het ook niet mogelijk is om lege subarrays op te nemen, maar wellicht is dat in dit verband ook niet noodzakelijk. Dat kon in sommige andere voorstellen ook niet, trouwens.

[Verwijderd]

Op zondag 17 februari 2002 18:01 schreef Soultaker het volgende:

[..]

Dat is eigenlijk nog wel de mooiste, aangezien je dan ook geen geheugen 'verspilt'. Een klein nadeel is wel, dat je de subarrays niet meer aan de hand van een index kunt ophalen. Je zal dus de hele array moeten doorlopen om het gewenste item te vinden. Intern kun je natuurlijk de pointer naar het eerste element van een subarray gebruiken, zodra je de goede subarray gevonden hebt.

Dat vond ik er idd ook het probleem van.... Ik heb voorlopig maar de { NULL } ipv NULL als afsluiter. Dan werkt het. Ik verspil wel geheugen maargoed, dat is maar enkele bytes (zoals je al wel zag gaat dit over video-/audio-recording, dan werk je met buffers van enkele soms enkele tientallen MBs (32 buffers x 2 MB/buffer = 64 MB), dus die paar extra byte maken niet zoveel uit )