Kód: Vybrať všetko

int * pole = malloc( 400 );

Kód: Vybrať všetko

int * pole = malloc( 100 * sizeof(int) );

Kód: Vybrať všetko

struct moja_struktura_t
{
    int cislo;
    hmm... // co sem?
}

Kód: Vybrať všetko

struct moja_struktura_t
{
    int cislo;
    void * dalsi_prvok;
}

Kód: Vybrať všetko

moja_struktura_t * n1 = malloc( sizeof(moja_struktura_t) );
n1->cislo = 42;
n1->dalsi_prvok = malloc( sizeof(moja_struktura_t) );

n1->dalsi_prvok->cislo = /// pockat, to nebude fungovat, ta adresa je void :/ Tak najprv si to musim previest, ach jo
moja_struktura * n2 = (moja_struktura_t *) n1->dalsi_prvok;
n2->cislo = 84;
n2->dalis_prvok = malloc( sizeof(moja_struktura_t) );
...

Kód: Vybrať všetko

struct moja_struktura_t
{
    int cislo;
    moja_struktura_t * dalsi_prvok;
}

Kód: Vybrať všetko

n1->dalsi_prvok->dalsi_prvok->dalsi_prvok->dalsi_prvok->cislo = 1024;
n1->dalsi_prvok->dalsi_prvok->dalsi_prvok->dalsi_prvok->dalsi_prvok = malloc...;

Kód: Vybrať všetko

void pridajCislo( moja_struktura_t * zoznam, int pcislo ) // zoznam je prvy prvok spojaku, pcislo chcem pridat na koniec.
{
    if( zoznam == null ) // ziadny prvy prvok este neexistuje
    {
         zoznam = malloc...
         zoznam->cislo = pcislo;
         zoznam->dalsi_prvok = NULL; // nastavim ako posledny prvok
         return;
    }

    if( zoznam->dalsi_prvok == null )
    {
         zoznam->dalsi_prvok = malloc...
         zoznam->dalsi_prvok->cislo = pcislo;
         zoznam->dalsi_prvok = NULL;
         return;
    }

    if( zoznam->dalsi_prvok->dalsi_prvok == null )
    {
         zoznam->dalsi_prvok->dalsi_prvok = malloc...
         zoznam->dalsi_prvok->dalsi_prvok->cislo = pcislo;
         zoznam->dalsi_prvok->dalsi_prvok = NULL;
         return;
    }

    if( zoznam->dalsi_prvok->dalsi_prvok->dalsi_prvok == null )
    {
         zoznam->dalsi_prvok->dalsi_prvok->dalsi_prvok = malloc...
         zoznam->dalsi_prvok->dalsi_prvok->dalsi_prvok->cislo = pcislo;
         zoznam->dalsi_prvok->dalsi_prvok->dalsi_prvok = NULL;
         return;
    }
    ...
}

Kód: Vybrať všetko

void pridajCislo( moja_struktura_t * zoznam, int pcislo )
{
     while( zoznam->dalsi_prvok != NULL )
         zoznam = zoznam->dalsi_prvok;
    
    // a tu by som mal byt na konci
    zoznam->dalsi_prvok = malloc...
    zoznam->dalsi_prvok->cislo = pcislo;
    zoznam->dalsi_prvok->dalsi_prvok = NULL;
}

Kód: Vybrať všetko

struct ll_entry_s {
	//predošlá a nasledujúca položka
	struct ll_entry_s * prev, next;
	
	//dáta ktoré budeme ukladať
	void * data;
};
typedef ll_entry_s ll_entry, *pll_entry;

Kód: Vybrať všetko

struct linkedlist_s {
	pll_entry first, last;
};
typedef linkedlist_s linkedlist, *plinkedlist;

Kód: Vybrať všetko

plinkedlist ll_new() {
	/* alokuj a vynuluj novú štruktúru pre spájaný zoznam */
	return (plinkedlist)calloc(sizeof(linkedlist));
}

Kód: Vybrať všetko

void ll_destroy(plinkedlist ll) {
	pll_entry tmp, curr = ll->first;
	
	//pokým ešte nie je koniec zoznamu
	while(curr!=NULL) {
		//ulož si nasledujúcu položku zoznamu
		tmp = curr->next;
		
		//dealokuj túto položku
		free(curr);
		
		//... a pokračuj ďalšiou položkou
		curr = tmp;
	}
	
	//nakoniec uvoľni aj samotnú štruktúru zoznamu
	free(ll);
}

Kód: Vybrať všetko

int ll_count(plinkedlist ll) {
	int i = 0;
	pll_entry curr = ll->first;
	
	//sme na konci
	while(curr!=NULL) {
		//...nie
		curr = curr->next;
		
		//tak pridaj
		i++;
	}
	
	return i;	
}

Kód: Vybrať všetko

int ll_count(plinkedlist ll) {
	int i = 0;
	pll_entry curr = ll->first;
	
	//sme na konci
	while(curr!=NULL) {
		//...nie
		curr = curr->next;
		
		//tak pridaj
		i++;
	}
	
	return i;	
}
void * ll_get(plinkedlist ll, int index) {
	int i = 0;
	pll_entry curr = ll->first;
	
	//pokým niesme na konci
	while(curr!=NULL) {
	
		//ak sme našli položku ktorú hľadáme
		if(i==index)
			//môžeme vrátiť pointer na jej dáta
			return curr->data;
		
		//inak ideme ďalej
		curr = curr->next;
		i++;
	}
	
	//našli sme koniec zoznamu, no nedosiahli sme požadovaný index
	//vraciame neplatnú hodnotu (0xffffffff na 32-bitových systémoch)
	return (void*)-1;
}

Kód: Vybrať všetko

int ll_set(plinkedlist ll, int index, void * data) {
	int i = 0;
	pll_entry curr = ll->first;
	
	//ešte niesme na konci?
	while(curr!=NULL) {
		//je toto položka ktorú cheme zmeniť?
		if(i==index) {
			//zmeňme ju
			curr->data = data;
			
			//vráťme index
			return index;
		}
		
		curr = curr->next;
		i++;
	}
	
	//nedosiahli sme potrebný index
	return (int)-1;
}

Kód: Vybrať všetko

void ll_add(plinkedlist ll, void * data) {
	//alokuj novú položku, ulož adresu na ňu do dočasnej premennej
	pll_entry tmp = (pll_entry)malloc(sizeof(ll_entry));
	
	//nastav dáta položky
	tmp->data = data;
	//predošlým elementom položky na konci zoznamu je bývalý koniec :)
	tmp->prev = ll->last;
	//zoznam ukončíme nulou, NULL
	tmp->next = NULL;
	
	//bývalá posledná položka musí ukazovať na novú
	ll->last->next = tmp;
	//základná štruktúra zoznamu musí tiež ukazovať na novú poslednú položku
	ll->last = tmp;
}

Kód: Vybrať všetko

int ll_remove(plinkedlist ll, int index) {
	int i = 0;
	pll_entry curr = ll->first;
	
	//pokým niesme na konci
	while(curr!=NULL) {
		//našli sme index ktorý hľadáme?
		if(i==index) {
			//ak áno, nasledujúce položka predošlej položky je nasledujúce položka aktuálnej položky
			curr->prev->next = curr->next;
			
			//predošlá položka nasledujúcej položky je predošlá položka aktuálnej položky
			curr->next->prev = curr->prev;
			
			//uvoľni aktuálnu položku
			free(curr);
			
			//vráť nezáporný index
			return index;
		}
		
		curr = curr->next;
		i++;
	}
	
	//v prípade neúspechu vráť zápornú hodnotu
	return (int)-1;
}

Kód: Vybrať všetko

zoznam_t * zoznam = NULL;

if( zoznam == NULL )
     zoznam je prazdny;

nahraj(zoznam);
if( zoznam == NULL ) // toto uz by sa vykonat nemalo. Iba ak sa vyskytla chyba a vtedy by funkcia nahraj nemala so zoznamom nic urobit (necha ho na NULL)
     zoznam je prazdny;

Kód: Vybrať všetko

typedef struct
{
    int a;
    int b;
    char c;
    char c2;
} zoznam_t;

int main()
{
    zoznam_t * zoznam2 = malloc( sizeof(zoznam_t) );
    printf( "%p\n", zoznam2 ); // adresa v pamati, kde je struktura ulozena
    zoznam2->a = 42;
    zoznam2->b = 43;
    zoznam2->c = 'B';
    zoznam2->c2 = 'X';
    free(zoznam2);

    zoznam_t * zoznam = malloc( sizeof(zoznam_t) );
    printf( "%p\n", zoznam ); // fiha!

    printf( "%d\n", zoznam->a );
    printf( "%d\n", zoznam->b );
    printf( "%c\n", zoznam->c );
    printf( "%c\n", zoznam->c2 );

    return 0;
}