Dynamicky clen v strukture – C / C++ – Fórum – Programujte.com

Zdravim,

predstavme si ze mame strukturu  

struct friends
{
    char meno[50];
    int pocet;
    char * zoznam = malloc(sizeof(meno) * pocet;
};

Jak by sa to dalo prosim korektne zadefinovat, aby ukazatel zoznam mal vyclenenu taku velkost pamate do ktorej sa zmesti mien najviac dlhych 50 znakov s poctom ktore bude obsiahnute v clenskej premennej pocet  ?

Potrebujem proste zo zadania "Tato struktura bude v sobě obsahovat jméno osoby, počet přátel a dynamicky alokované pole nebo seznam se jmény všech přátel." splnit toto aby sa do toho zoznam vpratal zoznam vsetkych mien priatelov. Snad som to napisal zrozumitelne.

Nejake napady ?

Dakujem za pripadnu odpoved.

ve struct budes mit pouze ptr napr. 

struct friends
{
    char meno[50];
    int pocet;
    char** zoznam; // slo by taky... char* zoznam[50];
};

a potom kdyz budes vytvaret instanci "friends", tak si alokujes seznam pratel jenom

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct friends
{
    char meno[50];
    int pocet;
    char * zoznam;
};

int main(int argc, char * argv[])
{
    if (argc != 3)
    {
        printf("Zly pocet argumentov\n");

        return 1;
    }

    struct friends lol;

    lol.zoznam = malloc(sizeof(char[50]) * 50);

    strcpy(lol.zoznam[0], "Blazko");

    printf("%c", lol.zoznam[0]);
   

nejak tomu celkom nechapem. zoznamu som teda v mainu vyclenil miesto na 50 clenne pole kde jedna polozka moze ulozit 50 znakovy retazec. Korektne to ale ocividne neni. 

char* => uchovava JEDEN retezec, takze seznam pratel => seznam retezcu => char**

EDIT: 

typedef struct
{
    char name[50];
    int friendsCount;
    char** friends;
} Friend;

int main()
{
    int i;
    Friend f;

    strcpy(f.name, "Humr");
    f.friendsCount = 2;
    f.friends = (char**)calloc(f.friendsCount, sizeof(char*));
    *f.friends = (char*)calloc(6, sizeof(char));
    strcpy(*f.friends, "Karel");
    f.friends[1] = (char*)calloc(4, sizeof(char));
    strcpy(f.friends[1], "Max");

    return 0;
}

aha takze v podstate je to pole ukazatelov na retazce. Nejak ale neviem jak mu korektne vyclenit ziadanu velkost 

#include <stdint.h>

struct friends
{
    char meno[50];
    int pocet;
    char** zoznam;
};

int main()
{
    struct friends lol;
    
    lol.zoznam = malloc(sizeof(char[50]) * 10);
            
    return 0;
}

je asi nekorektne ... Jak inicializovat potom jednotlive zlozky zoznamu, a jak ich uvolnit spat systemu ?

char** je pole ukazatelu na char*, takze pokud mas treba 2 prvky, tak potrebujes alokovat 2 ukazatele na char*

pokud nevis jakou ma velikost ukazatel (4byte), tak si stačí zavolat sizeof(char*) a potom staci jen alokovat klasickej char*, bud velikosti 50 nebo presnou velikosti jaky ma to jmeno+1

takze toto by mohlo byt spravne ? 

#include <stdint.h>

struct friends
{
    char meno[50];
    int pocet;
    char** zoznam;
};

int main()
{
    struct friends lol;
    
    lol.zoznam = malloc(sizeof(*char) * 10);
    *lol.zoznam = malloc(sizeof(char) * 50);
            
    return 0;
}

ma 10 kamaratov a dlzka mena je max 49 znakov + \0 ?

#7 Zajcev
podstatě jo, sice ti tam chybí přetypování a máš čistě alokaci ale ano 

struct friends lol;

lol.zoznam = (char**)calloc(10, sizeof(char*));
*lol.zoznam = (char*)calloc(50, sizeof(char));

a pouzivej calloc, ten ma jednak lepsi parametry a taky automaticky vynuluje prvky

Diki moc, uz to snad chapem a ide to :)

Este by som mal jednu dalsiu otazku. Konkretne existuje nejaky sposob jak ku polu ukazatelov na struktury ktore som dynamicky alokoval pridat dalsiu zlozku pola tiez typu danej struktury ? Napriklad mame strukturu  

struct typy {
	char typ[4];
	int pocet;
};

kde typ bude reprezentovat typ daneho suboru a pocet , pocet vyskytov tohto typu suboru v adresari. Ked najdem dalsi  subor s typom ktory uz je obsiahnuty tak proste inkrementujem premennu pocet a ked to bude novy typ tak pridam do toho pola dalsiu zlozku a pocet sa bude rovnat 1 ... V napovede mame toto : "Nápověda: typ souboru a počet výskytů lze udržovat ve vhodné dynamicky alokované struktuře a další přidávat jen v případě, že daný typ souboru se ještě nevyskytuje". Nejak neviem jak to zapisat.

Nejake napady ?

Dakujem za pripadnu odpoved.

kdyby si to dělal v c++, tak tam to jde uplne jednoduše přes mapu, ale pokud to chceš jak pises, tak mě napadají 2 moznosti, bude pres pole a to by si vzdy inc. pokud najdes typ, kterej tam jeste neni nebo pres seznam, kde by kazdej typ ukazoval na dalsi.. typ->typ->typ->0

struct bez definice nedelam, ale melo by to vypadat nejak takto 

struct typ {
    char nazev[4];
    int pocet;
    struct typ* dalsi;
};

Napr. takto to můze vypadat 

typedef struct TYPE
{
    char name[4];
    int count;
    struct TYPE* next;
} Type;

static Type* first = 0;
static Type* last = 0;

Type* exists(const char* name)
{
    Type* tmp = first;

    while (tmp != 0)
    {
        if (!strcmp(tmp->name, name))
            return tmp;

        tmp = tmp->next;
    }
    return 0;
}

void add(const char* name)
{
    Type* find = 0;
    Type* tp = (Type*)calloc(1, sizeof(Type));

    strcpy(tp->name, name);
    tp->count = 1;

    if (first)
    {
        if (!(find = exists(name))) last->next = tp;
        else
        {
            find->count++;
            free(tp);
            return;
        }
    }
    else first = tp;
    last = tp;
}

int main()
{
    add("exe");
    add("pdf");
    add("cpp");
    add("pdf"); // pocet 2

    return 0;
}