Stränghantering i C

Du behöver plugga mer kring pekare, och hur arrayer ibland kan tolkas som pekare.

Du skriver

char text1[20] = "blabla";

Detta skapar en array med 20 element, och fyller de 7 första med blabla och en nullterminator.

Man kan också skriva:

char text1[] = "blabla";
char *text2 ="blabla";

text1 skapar en array med så många tecken som behövs för att fylla med det du initierar till.

text2 är en pekare till en sträng, och initieras till att peka på strängen "blabla".

Tänk på att då du skriver "blabla" i C så skapar kompilatorn en skrivskyddad array någonstans med 7 bytes. Typen för "blabla" är const char*.

I din typedef har du egentligen två val för strängar. Du kan antingen göra som du gjort, dvs att har en buffer med plats för 20 tecken. Det är ju visserligen enkelt, men har problemet att antingen är bufferten för stor, och då slösar du utrymme, eller så är den för liten och då kan du inte lagra din sträng alls. Därför använder man ofta pekare istället.

typedef struct {
	int id;
	char *name;
	int age;
} Person;

Nackdelen är att du då måste börja allokera minne för strängarna.

newPerson.name = "Nisse";

Detta fungerar i min typedef, men inte i din eftersom newPerson.name inte är en typ kompatibel med (char*). För att kopiera strängar använder du strcpy (gör man strcpy i terminalen). Gör #include <string.h> i ditt program om du använder strcpy.

Jag är inte otroligt insatt i hur det funkar när det väl har kompilerat... men, jag tror att det är såhär, att när du deklarerar en variabel i en funktion, så allokeras minne för variabeln på stacken. Alltså, för varje variabel som deklareras så ökas stackpekaren med lika många steg som variabelns datatyp, och sedan accessas variablerna med stackpekaren och ett byte-delta för variabelns position. Typ såhär:

char a, b, c;
b = 1;
a = 3;
c = 2;

Blir: (asm-pseudokod)

push
push
push
load (stackpekare - 1), 1
load (stackpekare - 2), 3
load (stackpekare), 2
pop
pop
pop

(förutsatt att char är 1 byte på plattformen).

När du däremot deklarerar en variabel utanför en funktion, så tror jag att den allokeras på ett annat ställe i minnet, som inte förändras under programmets gång.

(EDIT2: Förresten, ska inte din main-metod returnera någonting?

(EDIT3: nu när jag läser din ursprungsfråga så ser jag att jag inte alls svarar på det du frågade... slarvigt läst, förlåt. Ignorera alltså detta meddelande
Men någon annan kan kanske svara på om jag har förstått det hela rätt?)

Enligt ANSI C -99 så skall main deklareras såhär:

Man måste inte göra return i main:

Variabler deklarerade utanför en funktion (t.ex. main()) är globala variabler. De är synliga för alla funktioner du har länkat in i ditt program. (Du kan även deklarera en global variabel som static int id; och då är den enbart synlig för alla funktioner i din fil.)

Globala variabler anses vara ondskefulla för att de är trådosäkra, fungerar dåligt i rekursion, tar plats även då de inte används, ger upphov till sidoeffekter, och allmänt försvårar läsbarheten.

En variabel deklarerad i en funktion lagras på stacken då funktionen blir anropad (och försvinner då funktionen returnerar). De är att föredra eftersom de löser de problem som jag listade med globala variabler.

Nackdelen är att du får mer minne att hålla koll på
Jag kan inte använda C's standardfunktioner, men jag förmodar att du gör ungefär såhär:
char *myString = (char *)malloc( 10 * sizeof( char ) );
Om du vill ha plats för 9 bokstäver i den. (den sista byten behövs för att terminera stringen, och måste ha värdet 0).

Om du redan kan php och framför allt tycker jag inte det är speciellt nödvändigt att traggla gammaldags C först. Jag skulle istället gå direkt på objective-C som liksom javascript och i viss mån php är objektorienterat. Att kunna Cs syntax är förstås aldrig fel, däremot tycker jag inte du ska lägga speciellt mycket tid på t ex C-funktioner du ändå aldrig kommer använda (t ex printf, malloc) när du kodar i Cocoa.

Stränghanteringen anses (av mig och många därtill) vara ebarmligt dålig i C och du kanske börjar inse varför.

Jag håller delvis med. Jag tycker du skall lära dig C bra, helst med en riktig bok. Sedan kan du gå över till att använda Apples NSString objekt.

Lär dig C, men fäst ingen större vikt vid C's standardbibliotek. Att kunna använda pekare, typedefs osv är dock nödvändigt när du skriver ObjC.

Jo, jag tycker nog att kunskap om strcpy, strcat, malloc, memcpy, memset, memmove, etc hör till baskunskaperna om man ska kunna C.

Poängen med C är att INGENTING (nästan) är automatiskt. Du kan (och måste ha) full koll på allt du gör. Du bör behärska pekare ordentligt om du ska jobba i C.

C kan betraktas som högnivåassembler. Om man behärskar C är stränghanteringen enkel, manuell och logisk.

Men jag håller med om att språket inte är idealiskt för slutapplikationer. På Mac är Objective-C ett intressant val. Annars skulle jag nog rekommendera ett "säkert" språk, typ Java. Eller kanske något "script-aktigt", typ Phyton eller Ruby.

Men för att förstå grunderna i hur datorer arbetar så är C ett bra val.

arrayen newPerson har du ju satt till 0 element, så klart att size blir 0.

De olika formerna av alloc (minnesallokering) är grundläggande i C, så fort du har dynamiska datastrukturer så måste du själv tilldela minnesutrymme. Och, vilket närmast är ännu värre, frigöra minne när det inte används!

(char *)malloc( 10 * sizeof( char ) );

sizeof( char ) returnerar antalet bytes typen char använder
10 * sizeof( char ) ger alltså plats för 10 st variabler av typen char
malloc(...) reserverar minnesplats för dessa
(char *)... typecastar referensen till minnet till att bli en char-pekare

...vilket är onödigt i C (men inte C++) eftersom malloc returnerar en void* och det är tillåtet att tilldela en void* till en char*

Nej, C har inte dynamiska arrayer alls. Du måste alltid själv hantera minne manuellt.

Du kan deklarera newPerson[10], t.ex. så skaffar du utrymme för exakt 10 personer. Men vill du ha dynamiskt antal personer bör du göra på ett helt annat sätt, och då blir det mer komplicerat och avancerat.

Du kan deklarera:
Person *newPerson;
..och sedan skaffa minne till t.ex. en person:

newPerson = malloc(1 * sizeof(Person));

...och sedan utöka minnet till två personer...

newPerson = realloc(newPerson, 2 * sizeof(Person));

Problemet med realloc är att den kan bli tvungen att kopiera hela arrayen, och då blir inte prestandan optimal. I så fall kan du välja någon annan datastruktur...

Om du inte kommer ihåg att friställa minne du allokerat så gör ingen annan det åt dig. Du läcker minne. Ditt program kommer att dra mer och mer minne för att till slut krasha.

Arrayer i exempelvis PHP är inte "riktiga" arrayer. Arrayen är en grundläggande datastruktur i minnet, vilket innebär att du lägger ett antal variabler av samma typ efter varandra, rent fysiskt. Du kan inte bara lägga till nya element, av den enkla anledningen att utrymmet efter kanske används av en annan variabel.

Arrayer är i princip bara vettiga att använda när du på förhand vet hur många platser du behöver. För dynamiska datasamlingar brukar andra konstruktioner användas, vill du ha en vettig snabbkurs i C tycker jag du ska skapa metoder för att implementera en länkad lista. Detta är en av de vanligaste datasamlingarna, och innehåller trevliga övningar i pekare, malloc, och annat mysigt!

...och det är här

Person *newPerson = [Person personWithName:@oskob];
NSMutableArray *array = [NSMutableArray array];
[array addObject:newPerson];

kommer in i bilden