udskrive en streng variabel

char er kun et bogstav.

Jeg tror at du mener:

char Template[] = "abc";

Du kan lave:

char Template[] = "linie 1\nlinie 2\nlinie 3";

eller:

char Template[] = "linie 1\n"
                  "linie 2\n"
                  "linie 3";

Og udskriv er f.eks.:

printf("%s\n",Template);

ja det hjalp!

Dog troede jeg at [] betød array, men sådan var det åbenbart ikke. :)

svar?

Og endnu engang tak for hjælpen, håber ikke du bliver træt at mine nybgynder ? :)

1) Din kode skulle nok have været noget lignende

char* Template = "abc";

void tell()
{
  printf("%s\n",Template);
}

int main(int argc, char** argv)
{
  tell();
  return 0;
}

Prøv at sammenligne de 2 kode-stumper, og se hvad din compiler fortæller dig er forkert.
Ex: Første fejl er i linie 3 i filen streng.c - dvs i linien
char Template = 'abc';

Tempate er en variabel af typen char. Men 'abc' er ikke en char type (er faktisk ikke noget kendt data type), du har sikker ment "abc" som er et char-array. En char pointer (char*) kan pege på et char array.

2) Hm, afhængig af dit ønskede formål kan du

a) char* mangelinier = "her er første linie\n"
            "her er anden linie\n"
            "her er tredie linie";

b) char mangelinier[1000];
  char* navn1 = "Kurt";
  char* navn2 = "Brian";
  sprintf(mangelinier,"a=%s\nb=%s\n",navn1,navn2);

C har (i modsætning til C++) slet ikke strenge.

Kun arrays af char.

Derfor [] for array !

svar

ok tak arne_v - men du glemte at svare :)

ttn.bonk> Det forstår jeg så godt, men kan/gider du forklare denne linie:

int main (int argc, char** argv)

Og hvorfor skal du ikke bruge 'void'?

Jeg hæver point, så der er lidt til jer begge :)

Nu så jeg at Arne faktisk nåede at svare lige inden mig, så det burde nok have været ham som fik points.

Jeg skrev
"int main(int argc, char** argv)" fordi det er standard erklæring af main rutinen.

Du kunne godt have skrevet
"void main()", men så skal din "return 0;" i sidste linie være "return";

Normalt returnerer man f.eks. 0 i main rutinen når alt er gået godt (return 0;), men er der sket en fejl laver man en fejlkode som fx "return 5;", hvor 5 tallet så er en eller anden fejlkode (bør beskrives i hvordan din *.exe fil bruges). Andre programmer som så kalder dit program kan så forsøge at tage højde for en fejl-situation. Laver du fx. et *.bat script som kalder din exe-fil kan så checke på om det gik godt eller ej.

De andre parametre "int argc, char**argv" er input til din main rutine. Prøv at lave flg. program:

int main(int argc, char**argv)
{
  printf("Antal argumenter = %d\n",argc);
  for (int i=0; i<argc; i++)
  {
    printf("Argument nummer %d = %s\n",i,argv[i]);
  }
  printf("Slut\n");
  return 0;
}


Oversæt det og kør din exe fil som noget lignende fra en DOS prompt (eller en shell i linux):

test.exe Kurt Brian Peter

hvor test.exe er dit oversatte program.


Mvh Torben.

C standarden siger at main skal være int ikke void.

Og som forklaret i et tdiligere spørgsmål, så er det også meget
praktisk at kunne returnere en status kode til shell.

Værdierne for den status kode er platform specifikke.

Men både Unix og DOS/Window bruger 0 for OK og >0 for fejl.

Jeg kender dog en platform hvor ulige=OK og lige=fejl.

stdlib.h definerer dog normalt 2 konstanter man kan bruge:
  EXIT_SUCCESS
  EXIT_FAILURE
(og de er så  0 og 1 på Unix og DOS/Windows - og 1 og 44 på den
platform jeg omtalte før)

Hvis man ikke skal bruge komamndo linie argumenter kan man erklære main som:

int main()

Hvis man skal bruge kommando linie argumenter kan man erklæremain som:

int main(int argc, char **argv)

eller:

int main(int argc, char *arrgv[])

[de 2 former er ekvivalente]

Rent faktisk har den helt ægte main 3 argumenter !

Men det er meget sjældent at det tredie argument bruges.

Eksempel:

#include <stdio.h>

int main(int argc, char *argv[], char *envp[])
{
  int i;
  char *p;
  for(i=0;i<argc;i++)
  {
      printf("%s\n",argv[i]);
  }
  i = 0;
  while((p=envp[i])!=NULL)
  {
      printf("%s\n",envp[i]);
      i++;
  }
  return 0;
}

Der er ingen envp til main ifølge C standarden. Nogle (men ikke alle) platforme understøtter denne form. I C standarden står der:

5.1.2.2.1 Program startup
1 The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent) or in some other implementation-defined manner.

2 If they are declared, the parameters to the main function shall obey the following constraints:
— The value of argc shall be nonnegative.
— argv[argc] shall be a null pointer.
— If the value of argc is greater than zero, the array members argv[0] through
argv[argc-1] inclusive shall contain pointers to strings, which are given implementation-defined values by the host environment prior to program startup. The intent is to supply to the program information determined prior to program startup from elsewhere in the hosted environment. If the host environment is not capable of supplying strings with letters in both uppercase and lowercase, the implementation shall ensure that the strings are received in lowercase.
— If the value of argc is greater than zero, the string pointed to by argv[0]
represents the program name; argv[0][0] shall be the null character if the
program name is not available from the host environment. If the value of argc is greater than one, the strings pointed to by argv[1] through argv[argc-1]
represent the program parameters.
— The parameters argc and argv and the strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination.