[C] struct in int[]

Malo sem že pozabil C, pa se že cel dan matram kako bi vpisal array števil v strukturo

struct person{
    int id;
    int t[3];
    char *name;
}janez;

janez.id = 15;
janez.name = "Janez Novak";
int m[] = {1,2,3};
?? janez.t = ??

ERGY to si pa čist falu zdej.

Hvala vsem, mi je ratalo dokončati kodo.

Kompliciranje z mallocom za brezveze.

Saj ne grejo na stack... Če ga je volja jih lahko komot 5 milijonov v kodo nakuca.

A je to še resna debata? :)
String (kot std::string) se jasno alocira na heapu.
Če ima:

janez.name = "Janez Novak";

Potem "Janez Novak" pristane nekje v virtualnem naslovnem prostoru procesa in se naloži tja skupaj s samo programsko kodo. Edina stvar, ki lahko pristane na stacku je pointer janez.name, pa še to ne nujno.

string ne gre v .data segment. Kja gre samo začetna vrednost, ki se v konstruktorju kopira na heap.

technolog je 10. nov 2011 ob 18:48 izjavil:

string ne gre v .data segment. Kja gre samo začetna vrednost, ki se v konstruktorju kopira na heap.

Testni program:

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

int main()
{
        char *str = "Test string\n";
        printf(str);
        return 0;
}

Izhod "gcc -O3 -S" na linuxu:

        .file   "test.c"
        .section        .rodata.str1.1,"aMS",@progbits,1
.LC0:
        .string "Test string"
        .text
        .p2align 4,,15
.globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        andl    $-16, %esp
        subl    $16, %esp
        movl    $.LC0, (%esp)
        call    puts
        xorl    %eax, %eax
        leave
        ret
        .size   main, .-main
        .ident  "GCC: (Debian 4.4.5-8) 4.4.5"
        .section        .note.GNU-stack,"",@progbits

Uporablja direktno naslov stringa v .data segmentu. Again... To je C, ne C++. Tisti jezik, kjer še ni konstruktorjev, pa tudi podatkovnega tipa string ne.

Še tretjič... V programskem jeziku C ne obstaja std::string. To je v C++. Drug programski jezik.

@BigWhale: char foo[10] = "1234567890" bo pa na stacku, ker je foo lokalna spremenljivka, inicializacija bo pa izvršena s serijo move ukazov.

Ok, nevem zakaj sem omenjal string. String je iz ene druge teme. Se pardoniram.

Ja, ce imas char * potem je treba malloc() uporabiti.

char *str je samo pointer. Kaže lahko kamor koli hočeš. Lahko kaže na heap (malloc), lahko kaže direkt v data segment ("Bla bla"). Lahko pa narediš malo bolj tricky pointer ala char str[] = "Bla bla". V tem primeru bo "Bla bla" v data segmentu in se potem skopira na stack in str torej kaže na stack.

Spet ne nujno...

char str[512];
strcpy(str, "Bla bla");

vs.

char *str = malloc(512);
strcpy(str, "Bla bla");
free(str);

Govoril sem o pointerjih na character. Torej, da bom povsem natancen, kadar imas pointer na character, in mu ne assignas vrednosti pred prevajanjem, moras zadevo potem urediti z m/calloc(), drugace se ti ne obeta nic dobrega.

Ce imas pa array of characters je pa stvar seveda drugacna. :) In spet je razlika med char[] in pa char[50].

Technolog:

int starost = 17;

'starost' je objekt tipa int.

int *p_a;
int a[12];

Objekta 'a' in 'p_a' si nista enakovredna. 'a' je objkt tipa tabele desetih 'int' vrednosti, objekt 'p_a' je kazalec na objekt tipa int. To, da mislis da sta ta dva stavka enakovredna je tipicna zacetniska napaka.

Deklaracija praznega arraya je enaka kot deklaracija arraya s podano dimenzijo. Razlika je le v tem, da pri prvi deklaracijo dimenzijo arraya ugotovi prevajalnik s pomocjo inicializacije take tabele.

Torej tvoja prejsnja izjava se vedno ne drzi.

MrBrdo, zmeden si. int a[10] je objekt tipa tabele za 10 int predmetov. int *a je kazalec na objekt tipa int.
Sm se spomnu da sem ze enkrat pisal o tem, mogoce komu prav pride:

http://napotnik.info/c/node2.html

technolog: ne sirit krive vere ... objekt je nek prostor v pomnilniku, na katerega se ti lahko sklicujes preko imena (spremenljivka)

int a[10] ustvari tabelo za 10 int objektov ...

Taksna je vedno bila definicija objekta. Ce ne verjames, se prosim obrni na kaksno strokovno knjigo (recimo K&R).

Sicer se mi res ne da vec ponavljat 2x povedanega ... tabela != kazalec ... pozanimaj se preden se skodujes drugim ...

Spet brc v temo ... lej ti nic ne skodi ce bi sam malo pogooglu preden bi se spustil v to debato ... ne, c mi ni tuj zato prosim malo pobrskaj preden odgovoris :)

In kaj naj bil koda dokazala? Gre se samo za drugacno notacijo dereferenciranja ....

zmotil si se pri trditvi, da drzi array == pointer kar se vedno vztrajno trdim da to ne drzi

Om ok ... recmo da mas prav. Potem bi sledeca koda morala delovati:

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

int main() {
    char a[] = "Janez";
    char *b = "Metka";

   // torej, ce sta a in bi enaka (oba dva tipa char*),
   // potem se to mora prevesti

    a = "Novak";
    b = "Kardelj";
}

tabela ni samo pojem, gre se za drugacno predstavitev podatkov v pomnilniku ... ce si stari macek potem ga je nekdo mocno zalomil ...

napsy: ti pa si smešen. Trdiš nekaj, kot utemeljitev pa daš link na nekaj kar si sam napisal. Zelo kredibilno

In sploh ne gre za drugačno predstavitev podatkov v pomnilniku. V obeh primerih imaš string literal (ki se po vsej verjetnosti nahaja v .data sectionu programa), in kazalec nanj. Razlika je samo v tem ali je kazalec konstanta ali ne, ter ali prevajalnik generira ukaze za kopiranje literala v sklad ( v primeru ko uporabljaš [] bo kopiral na sklad, sicer je kazalec direktno v data section)... To pa nima veze (v tem primeru) s predstavitvijo v pomnilniku ampak samo s tem, kaj počne prevajalnik. Če bi npr. v tvojem primeru uporabil inline assembler bi lahko spremenil vrednost tudi za a (predvidevam da te to "moti"). In spremenil bi KAZALEC ne pa vsebino! Saj vsebine string literalov NIKOLI ni dovoljeno, čeprav včasih to lahko narediš (v kolikor data section ni write-protected) ampak so posledice nedoločljive. V primeru ko imaš [] notacijo prevajalnik SKOPIRA literal iz data sectiona v sklad, zato tudi vsebino lahko spreminjaš. Še vedno pa gre za KAZALEC, nikakor pa ne za objekt.

Še enkrat, v C NI OBJEKTOV, so samo primitivni podatkovni tipi ter strukture, objektov pa NI.

Pa poskusi obratno, char * priredi vrednost char[6]. Po tvoji logiki ne bi smelo it skozi, pa gre... In kaj dobiš, če castaš char[6] v (int) (char *) in izpišeš vrednost (dobiš vrednost kazalca)? In zakaj ni warningov? Razloži...
V obratnem primeru gre za napako ker je podatkovni tip bolj natančno določen, in ker ni nujno da ima char * vsebino točno 6 znakov. To nima prav nobene povezave z predstavitvijo v pomnilniku ampak le s tem da te prevajalnik hoče zaščitit pred napakami. Še vedno gre za kazalec le da pri char[6] vemo, da kazalec kaže na pomnilniški prostor velikosti 6*sizeof(char), medtem ko velikost rezerviranega prostora pri char * ni implicitna v podatkovnem tipu.

Razlagat ti ni potrebno saj nimaš prav. Za razumevanje delovanja C na tem nivoju kot se mi pogovarjamo pa je žal potrebno poznavanje arhitekture sistema, kar poznaš npr. če poznaš assembler. Boš moral še malo mleka popit, preden ti bo jasno.
C pozna primitivne podatkovne tipe in strukture. To je to. Nobenih objektov. Lahko pa najdeš kredibilen vir (to ni tisto kar si ti sam napisal) in nam dokažeš nasprotno.

Ne bo eksplicitno castal, če že kaj bi implicitno castal, česar pa v tem primeru tudi ne rabi počet, ker gre za popolnoma kompatibilna podatkovna tipa, noben cast ni potreben.

VREDNOST a je POMNILNIŠKA LOKACIJA kar pomeni da je a KAZALEC. Preveri sam:

int a[6];
printf("%d", (int) a);

Kako da izpiše pomnilniško lokacijo če pa po tvojem ne gre za kazalec? Nobene logike!

Seveda se pretvori, ker sta popolnoma ekvivalentna iz arhitekturnega stališča. Ti lahko arrayem zaradi mene rečeš objekti, ampak delovanje je popolnoma enako kot pri kazalcih. In tudi ko se stvar prevede v machine code je operiranje z kazalci, saj platforma (v tem primeru IA32) ne pozna koncepta arrayov.
Razlika med kazalcem in arrayom v Cju je samo v tem kakšne operacije ti prevajalnik nad njimi pusti izvajat. V končnem smislu pa vedno pridemo na kazalce.