Pointer behandling!

lytter med

1 Pointeren flyttes til funktion.

void Function(char** Names, int count)
{
  for (count--; count>=0; count--)
  printf(\"%s\", Names[count]);
}

...
  char* Names[max];
  Function(Names);
...

2 Pointeren overføres til anden variabel
  så der kan incrementeres med \"n_temp++;\"

Hvad mener du med det????

3 Variablens indhold skal sammenlignes med
  andet navn i et array \"Ikke nødvendigvis\"
  pointer notering.

Æhh? Jeg forstår stadig ikke din \"anden variabel\", og hvad det lige er den skal.

4 Compileren må IKKE fremkomme med WARNINGS!


Okay. Jeg har ikke lige testet det, men hvis der kommer nogle warnings, burde det kunne klares med simple typecast.

DMK

Hermed REN ANSI C løsning der kan kompileres under TC 3.0 uden fejl/warnings:

#include <conio.h>
#include <string.h>

#define  maxStr 8

int main(void)
{
  char *strPtr[maxStr] = {
                          {\"Streng A\"}, {\"Streng B\"}, {\"Streng C\"}, {\"Streng D\"},
                          {\"Streng 1\"}, {\"Streng X\"}, {\"Streng 3\"}, {\"Streng X\"}
                        };

  char Buffer[256];

  /* Flyt streng pointeren til en funktion. */
  strcpy(Buffer, strPtr[1]);
  strcat(Buffer, strPtr[2]);
  cprintf(\"Streng 2 (idx 1) = %s og 3 (idx 2) = %s giver:\\r\\n= %s\\r\\n\",
          strPtr[1], strPtr[2], Buffer);

  /* Overflytning af pointer til anden variabel m/increment. */
  char **tmpPtr = strPtr;  /* S‘t start adresse. */
  tmpPtr      += 3;      /* Flyt til det tredie element. */

  cprintf(\"Strengen efter streng 4 (idx 3) = %s er:\\r\\n= %s\\r\\n\",
          strPtr[3], /* Dereference for at se indholdet/strengen. */ *(++tmpPtr));

  /* Sammenlign indhold af to forskellige strenge fra tabel .. og fast. */
  strcpy(Buffer, strPtr[5]);
  if (strcmp(Buffer, strPtr[5])    == 0)
    cprintf(\"Streng nr. 6 (idx 5) = %s er den samme som indholdet i buffer = %s.\\r\\n\",
            strPtr[5], Buffer);

  if (strcmp(strPtr[5], strPtr[7]) == 0)
    cprintf(\"Streng nr. 6 (idx 5) = %s er den samme som streng 8 (idx 7) = %s.\\r\\n\",
            strPtr[5], strPtr[7]);

  /* Afslut */
  return 0;
} /* main */

Bemærk at du er nødt til at deference din \"increment\" pointer for at få fat i selve indholdet af den streng der peges på. Husk på at ptrStr[] jo er et areal a POINTERE til strenge, dvs. tmpPtr peger på et pointer areal. For at se den reelle streng, skal du derfor først have fat i den rigtige pointer i det element som tmpPtr peger på - derfor derefereres med *. Så har du pointeren til den rent faktisk streng, som du kan bruge f.eks. som her i et kald til cprintf.

Forslaget ser nogenlunde ud, men ikke tilfredsstillende.

Når jeg mener at man skal kunne skrive
variabel++, mener jeg at man skal kopiere pointer adressen over i en anden variabel for at opnå en metode uden at skrive : *(navn+[max++] )

Som du ser incrementerer du array elementet med 1.

For at reducere kompleksiteten i syntaksen kan man faktisk skrive variabel++, som ikke er en pointer constant, men en pointer variabel.

Og husk lige på at der ikke er tale om at der reserveres antal plads i et streng array når der bruges pointere. Det vokser alt efter hvor stort brugeren vælger det skal være.
Du angiver jo ikke :
---------------------------------------------
*pointer_array == (max 10)
/* ikke gyldigt udsagn om pointere!!! */
---------------------------------------------

Mvh
jackonlinux >> PS: n_navn++ spring til næste element;

Prøv du lige at nærlæse koden igen min ven - jeg incrementerer tmpPtr (som svarer til din n_navn) direkte - men det ændrer sgu\' ikke på at det stadig er en pointer til en pointer og den derfor skal de-refereres for at du kan få fat i indholdet af strengen.

Hvis du er så \"dygtig\" forstår jeg slet ikke du søger svar her på eksperten - og så blankt afviser de svar du får !

Soepro jeg kan naturligvis godt se at du har ret -og jeg afviser det heller ikke, men har så været ved at læse i mine bøger.

Du får 60 point - håber du er tilfreds.

Mit store problem ved funktioner er at keg skal overføre pointer adressen.

Når man så har *navn er det vel ikke nødvendigt at skrive &navn hva?

Hvad gør man så?

&navn er til overførsel af såkaldte reference pointere. De virker egentlig fuldstændigt som en alm. pointer, dog behøver man ikke at skrive -> efter navnet, men kan skrive . i stf. Der er forskel i måde de to skal kaldes på:

int add2(int &navn)
{
  return navn += 2;
}
skal kaldes add2(temp)

int add2(int *navn)
{
  return *navn +=2;
}

skal kaldes add2(&temp). Personligt foretrækker jeg den sidste syntaks, fordi man så kan se begge steder, at den overførte variabel kan (men ikke nødvendigt at den bliver) rettet. Hvis du har en int* til ovenstående skal det første kald (via &) være uændret, mens det andet kald (*) skal være UDEN & foran temp, da temp jo i forvejen er en pointer.