Hoe tweedimensionale reeks structuren doorgeven om te functioneren?

Er is een tweedimensionale reeks structuren, ik geef een array-pointer door aan een functie:

result.capabilities = (Capabilities **)malloc(sizeof(Capabilities *)*6);
for(int i=0;i<6;i++){
    result.capabilities[i] = (Capabilities *)malloc(sizeof(Capabilities)*8);
}
init_capabilities(&result.capabilities);

Functie aanroep veroorzaakt een foutmelding:

Niet-verwerkte uitzondering op 0x003c10f9 in solution.exe: 0xC0000005: schending van toegangsschrijflocatie 0xfdfdfdfd.

Dit is mijn functie:

void init_capabilities(Capabilities ***capabilities) {
    for(int i=0;i<6;i++){
        for(int j=0;j<8;j++){
            printf("%d %d\n",i,j);
            capabilities[i][j]->room_capabilities = new RoomCapability[rooms_count];
        }
    }
}

Ik dacht dat de dimensie van de array mogelijkheden - 6x8. Het bleek dat 1x6. Een uur hoofdpijn daarom. Laat je zien hoe je het type argument kunt wijzigen of hoe je naar elementen van mijn array kunt verwijzen, zodat alles op zijn plaats viel?

0
Wees geen driester programmeur . Dat levert alleen maar pijn op.
toegevoegd de auteur R. Martinho Fernandes, de bron
Dit is echt een slechte C/C ++ mixcode. En als ik slecht zeg, bedoel ik het. Gebruik malloc niet in C ++. Gebruik waar mogelijk en haalbaar verwijzingen in C ++.
toegevoegd de auteur Xeo, de bron
Is dit C of C ++? Omdat ik denk dat ik je kan helpen als je in C ++ schrijft met nieuw in plaats van malloc() die C ++ biedt (wat je veel schonere, duidelijkere syntaxis geeft en veiliger is) dan malloc() IIRC).
toegevoegd de auteur dmn, de bron

3 antwoord

U geeft uw aanwijzer-naar-aanwijzer-naar-mogelijkheden door aanwijzer. Dat is waarom je drie sterretjes hebt in plaats van twee.

Probeer dit:

void init_capabilities(Capabilities ***capabilities) {
    for(int i=0;i<6;i++){
        for(int j=0;j<8;j++){
            printf("%d %d\n",i,j);
           //Note: extra dereference:
            (*capabilities)[i][j].room_capabilities = new RoomCapability[rooms_count];
        }
    }
}

Or this:

result.capabilities = (Capabilities **)malloc(sizeof(Capabilities *)*6);
for(int i=0;i<6;i++){
    result.capabilities[i] = (Capabilities *)malloc(sizeof(Capabilities)*8);
}
init_capabilities(result.capabilities);//Note NO address-of operator

// Note: two stars, not three
void init_capabilities(Capabilities **capabilities) {
    for(int i=0;i<6;i++){
        for(int j=0;j<8;j++){
            printf("%d %d\n",i,j);
            capabilities[i][j].room_capabilities = new RoomCapability[rooms_count];
        }
    }
}

Of, omdat je codeert in C ++, niet C:

// Assuming that result.capabilities and Capabilties::room_capabilities are declared
// vectors of the appropriate types ...
result.capabilities = std::vector >(std::vector(8),6);
init_capabilities(result.capabilities);

void init_capabilities(std::vector& capabilities) {
    for(int i=0;i
2
toegevoegd
In init_capabilities zou het niet . moeten zijn in plaats van -> ?
toegevoegd de auteur anatolyg, de bron
@anatolyg - je hebt waarschijnlijk gelijk. Ik heb het veranderd.
toegevoegd de auteur Robᵩ, de bron

Verklaren

void init_capabilities(Capabilities ***capabilities)

zoals

void init_capabilities(Capabilities **capabilities)

en kom langs

init_capabilities(result.capabilities); 

You just need to pzoalss the pointer to your array structure, not a pointer to the pointer of your array structure.

Edit: And zoals others have pointed out, if you're going to use C++ you should really be using new zoals in:

result.capabilities = new (Capabilities *)[6];
for(int i=0;i<6;i++) {
  result.capabilities[i] = new Capabilities[8];
}
init_capabilities(result.capabilities);

...

void init_capabilities(Capabilities **capabilities) {
  for(int i=0;i<6;i++) {
    for(int j=0;j<8;j++) {
      capabilities[i][j].room_capabilities = new RoomCapability[rooms_count];
    }
  }
} 

And don't forget to use delete[]. Better yet, do zoals Rob suggests and use the pre-defined C++ containers to handle this sort of thing. But if you really want to use unsafe pointers, what I have above should get it done for you.

1
toegevoegd

Je hebt hier een hele hoop problemen:

  1. U wijst ruimte toe voor elke afzonderlijke Capability en maakt vervolgens een nieuwe, de toegewezen ruimte in de vuilnis doen
  2. Je behandelt het mogelijkheden als een 2d array, wanneer het eigenlijk een reeks aanwijzers is naar arrays
  3. U geeft het adres van deze algemene array door, maar wel niets om het te waarderen in de functie

Totdat je duidelijk krijgt wat je probeert te doen, HOE het te doen zal moeten wachten.

0
toegevoegd