Kopírovanie referenčnej premennej.

[Radus]

Zdravím, pánov programátorov.
Viete mi prosím poradiť ako riešite kopírovanie referenčnej premennej? Majme napríklad štruktúru ´a´ a z nej potrebujem spraviť kópiu ´b´, ale samozrejme keď napíšeme b=a a v b zmeníme niečo, zmení sa to aj v a, lebo sme len skopírovali referencie, veď to poznáme...
Máte nato nejakú fintu? Či v C, C# alebo VB.
Narazil som len spôsob s použitím serializácie a pomocou streamu znovuvytvorením objektu, ale to sa mi zdá ako škrabať si hlavu dookola...
Vo VB som to chcel oklamať pomocou takejto funkcie:

Kód: Vybrať všetko

    Private Function copy_struct(ByVal _a As a_struct) As a_struct
        copy_struct = _a
    End Function

...ale neoklamal som Aj keď je tam označenie že funkcii sa predáva len hodnota (ByVal)...stále je to referencia a objekt ostane jeden...
Existuje na to nejaké elegantné riešenie? (Prejsť štruktúru pomocov cyklov to ručne kopírovať mi prosím neraďte...)

[peterple]

Neexistuje.

Ak chceš kopírovať štruktúru, objekt ktorý si si vymyslel sám tak si to musíš spraviť sám, lebo len ty rozumieš čo je čo a ako to treba robiť. A to je to čo robiť nechceš, lebo je to podľa teba ručne. Ale inak sa to nedá.

V objektových jazykoch má ten prapredok všetkých objektov aj funkciu clone (JAVA) alebo Clone (C#) ale robí to často hlúposti lebo prd rozumie tomu ako sú natrepané data v objekte.
Sú situácie keď objekt musí byť kopírovatelný, alebo odložitelný. V takom prípade jeho autor za spôsob kopírovania alebo sérializáciu ručí. A tú námahu s vytvorením tých funkcií si dá.

Prečo to tak je? Tu treba vidieť hlboko do memory manažmentu konkrétneho jazyka. A pritom to zahŕňa aj znalosť danej hw architektúry.
Nejaké čítanie k tomu
https://stackoverflow.com/questions/785 ... ng-objects

a lepšie názornejšie naznačené problémy pre JAVA
https://stackoverflow.com/questions/869 ... ct-in-java

Záver - ak objekt má možnosť serializácie tak je to najpohodlnejšia metóda ako ho skopírovať. Na druhej strane je najmenej efektívna.

[Radus]

Ďakujem za odpoveď, aspoň to mám polopate
Nie že by som to pomocou cyklov nechcel robiť, totiž to ja to tak robim teraz, lebo sa mi to zdá trochu jednochšie ako serializácia (nemyslím dĺžkou kódu ale programového zaťaženia)...tak len toľko.
Chcel som len vedieť či neexistuje nejaká jednoduchšia cesta...
Ďakujem za vysvetlenie.
R.

[martin knocik]

Existuje relativne jednoducha cesta pomocoua pointerov. 2 pointery odkazujuce na jednu a tu istu štrukturu.

[pocitujlasku]

martin knocik: celkom ma to zaujima, len si to akosi neviem predstavit. Ako pomocou 2 pointerov skopirujes data z jednej premennej do druhej bez toho, aby si ich rucne mapovat a nastavoval. On chce urobit kopiu s tym, aby boli nezavisle.

[Radus]

To je práve to čo sa stane keď napíšeš "b" štruktúra = "a" štruktúra, lebo pri referenčných typoch je meno štruktúry už odkaz na referenciu nie na hodnotu, čiže niečo ako pointer. (Platí to aj pre meno poľa). Takže sa presne to stane - máš 2 odkazy na jednu štruktúru...
Rozmýšľal som či ešte nevytvoriť univerzálnu rekurzívnu funkciu na kopírovanie štruktúru...

[Marekodzapadu]

Odporucam si precitat literaturu k danemu jazyku, lebo co jazyk to ina implementacia . Existuju dva typy, shallow copy (plytke) a deep copy (hlboke).

Napr pre C:

Kód: Vybrať všetko

/* deep copy - static */
typedef struct _str_t {
    char value [40];
}str_t;

...
str_t * mojaDynamickaStruktura_A = malloc(sizeof(str_t)); /* Alokujeme si dynamicku strukturu A */
str_t * mojaDynamickaStruktura_B = malloc(sizeof(str_t)); /* Alokujeme si dynamicku strukturu B */

memcpy(mojaDynamickaStruktura_A, "heslo", 5); /* nakopiruje retazec "heslo" do struktury */
memcpy(mojaDynamickaStruktura_B, mojaDynamickaStruktura_A, sizeof(mojaDynamickaStruktura_A); /* skopirujme strukturu A do struktury B*/
/* obe struktury budu identicke, ale kazda ma svoju vlastnu pamat */
    
/* #shallow copy - dynamic */    
typedef struct _buf_t {
    char *pvalue;
    char id;
}buf_t;

...
str_t * mojaDynamickaStruktura_X = malloc(sizeof(buf_t)); /* Alokujeme si dynamicku strukturu X */
str_t * mojaDynamickaStruktura_Y = malloc(sizeof(buf_t)); /* Alokujeme si dynamicku strukturu Y*/
mojaDynamickaStruktura_Y.pvalue = malloc(40); /* alokujeme pamat pre pointe pvalue */
memcpy(mojaDynamickaStruktura_Y.pvalue, "heslo", 5); /* nakopiruje retazec "heslo" do bufferu na ktory ukazuje pvalue */  
  
memcpy(mojaDynamickaStruktura_B, mojaDynamickaStruktura_A, sizeof(mojaDynamickaStruktura_A); /* skopirujme strukturu A do struktury B*/
/* kam ukazuje pValue v mojaDynamickaStruktura_B.pvalue ??? */
    
    
/* #teraz plny deep copy */    
str_t * mojaDynamickaStruktura_K = malloc(sizeof(buf_t)); /* Alokujeme si dynamicku strukturu X */
str_t * mojaDynamickaStruktura_L = malloc(sizeof(buf_t)); /* Alokujeme si dynamicku strukturu Y*/

mojaDynamickaStruktura_K.pvalue = malloc(40); /* alokujeme pamat pre pointer pvalue */
mojaDynamickaStruktura_K.id = 15); /* dame nejake id... */
memcpy(mojaDynamickaStruktura_K.pvalue, "heslo", 5); /* nakopiruje retazec "heslo" do bufferu na ktory ukazuje pvalue */  
  
memcpy(mojaDynamickaStruktura_L, mojaDynamickaStruktura_K, sizeof(mojaDynamickaStruktura_L); /* skopirujme strukturu A do struktury B*/
mojaDynamickaStruktura_L.pvalue = malloc(40); /* alokujeme pamat pre pointre pvalue */ 
memcpy(mojaDynamickaStruktura_K.pvalue, mojaDynamickaStruktura_L.pvalue, 5); /* nakopiruje retazec "heslo" do bufferu na ktory ukazuje pvalue */  
            
/* Obe struktury su identicke, a kazda ukazuje na svoju cast pamata, ktora je tiez identicka co sa tyka obsahu */

[zen]

Takže sa presne to stane - máš 2 odkazy na jednu štruktúru...

Ja som sa tymto stretol v Python. Aj ked sa mi to podarilo vyriesit, stale mi vrta hlavou, NA CO JE TO DOBRE, mat dva odkazy na tu istu strukturu.

[peterple]

Dobré je to na to že je to najjednoduchší spôsob pri odovzdávaní parametrov funkciám. Napríklad budeš mať nejaký zoznam hodnôt. A chceš urobiť funkciu ktorá vypočíta priemer. Tak niekde si držíš odkaz na ten zoznam. A zavoláš funkciu na výpočet priemeru. Ako parameter bude odkaz na ten zoznam. Vo funkcii vznikne dočasná premenná ktorá ukazuje tiež na ten zoznam. A už to máš dva odkazy čo ukazujú na tú istú štruktúru.
Iný príklad je zjednodušiť si zápis. Ak mám nejaký objekt ktorý sa skladá z objektov a tie zase z objektov. A ja potrebujem niekde pracovať veľa krát s nejakým jedným ale hlboko zanoreným. Tak si vytvorím premennú ktorá ukazuje na ten objekt, aby som to nemusel zapisovať stále dokola. A zase mám dva odkazy na to isté. Je to pohodlné a ešte ušetrím čas čo by sa to stále muselo vyhodnocovať.

Dôležité je aby tie ďalšie odkazy boli naozaj dočasné a čo najskôr ako ich nepotrebuješ zanikli. Lebo ak nie a ty zrušíš ten originál a predpokladáš že GC ti uvolní pameť, tak si si práve nabehol a vyrobil si memory leak.

[zen]

Dobré je to na to že je to najjednoduchší spôsob pri odovzdávaní parametrov funkciám. Napríklad budeš mať nejaký zoznam hodnôt. A chceš urobiť funkciu ktorá vypočíta priemer. Tak niekde si držíš odkaz na ten zoznam. A zavoláš funkciu na výpočet priemeru. Ako parameter bude odkaz na ten zoznam. Vo funkcii vznikne dočasná premenná ktorá ukazuje tiež na ten zoznam. A už to máš dva odkazy čo ukazujú na tú istú štruktúru.

Ta vyhoda mi porad unika. V Python by som to pisal takto:

Kód: Vybrať všetko

def priemer(a):
  return (sum(a)/len(a))
#-----
a=[1,2,3,4]
print(priemer(a))

Akoze ten odkaz uz mam, tak preco s nim nerobit? Funguje to, no alespon v tomto priklade to len komplikuje:;

Kód: Vybrať všetko

def priemer(a):
  b=a
  return (sum(b)/len(b))
#-----
a=[1,2,3,4]
print(priemer(a))

[maskrtnik01]

Kód: Vybrať všetko

def priemer(a):
  return (sum(a)/len(a))
#-----
a=[1,2,3,4]
print(priemer(a))

Ja aj tu vidím dve premenné, alebo ak chcete odkazy. Jeden je parameter funkcie priemer. Druhý patrí inej funkcii. Nemusí sa jednať o globálnu premennú, takže to že majú rovnaký názov ešte neznamená že existuje len jedna premenná.

[Radus]

Ahoj Zen. Peterple to myslel tak, že keby si funkcii neodovzdal referenciu na premennú ale rovno jej hodnotu, daná funkcia by vytvorila kópiu tej premennej a pracovala by ďalej s ňou.Teda pamať by sa alokovala 2x. Ak funkcii odovzdáš odkaz na referenciu (teda len odkaz kde sa nachádza premenná v pamati), daná funkcia pracuje stále s tou istou premenou. Takže máš quazi 2 a viac odkazov na dannú premennú(štruktúru). Dajme tomu raz v tele programu a raz v danej funkcii ktorú voláš. Podľa mňa by mal mať užívateľ možnosť si zvoliť či chce použivať hodnotu alebo referenciu premennej. Pri hodnotových typoch to ide, máme nato pointery a podobne. Pri referenčných typoch to už nejde, stále sa predáva len odkaz na referenciu. Je to dané aj iným umiestneným týchto typov v pamati. Tiež nechápem, ak program dokáže bez problémov založť novú premennú typu mojej vlastnej štruktúry alebo poľa, prečo sa nedá jednoducho vytvoriť jej kópia...ale ako vysvetľovali viac skúsený úživatelia, asi to neje také jednoduché...
No nič, ostáva nám sa s tým len zmieriť.

[peterple]

presne tak ako píše maskrtnik01. Už v tom prvom kóde máš dve referenčné premenné. Tu je pekne vidieť ako si programátor vo vyšších jazykoch nevie vôbec predstaviť čo sa v tom počítači deje.
napr že

Kód: Vybrať všetko

a=[1,2,3,4]

´
v skutočnosti vyrobí referenčnú premennú s názvom a ta má velkosť danú použitým CPU teda 32 alebo 64bit a obsahuje adresu nejakého kusu pamäte. A teraz kde a ako. Nuž to je dnes tak že sa zavolá konštruktor objektu List a ako parametre sa mu dá ten zoznam prvkov a on si zistí koľko tam tých prvkov je a čo sú zač. Nepoznám python, ale dajme tomu že sa v vypýta z OS kus pamäte a a to je ten objekt list. A potom vytvorí postupne zoznam objektov v tomto prípade čísel. To je všetko interná záležitosť toho objektu List. Ten si zapamätá koľko a kde a aké tie prvky sú. Teda celé to v pamäti zaberá kus ďalšej pamäte. Do premennej a sa dá len adresa kde bol ten objekt list vytvorený.
A teraz ideš volať tú funkciu priemer. A tá má ako jeden parameter objekt pola. Už teraz vieme že je to v pamäti ten samotný objekt plus data. Tá funkcia sa nemôže odvolávať na nejakú konkrétnu adresu, lebo ju môžeš zavolať s x rôznymi poľami. A tak je tam zase len miestečko na referenciu na ľubovolné pole (objekt) a to si si zase nazval a. Pri zavolaní funkcie sa len prekopíruje tá adresa z jedného a ktoré vidí ten hlavný program do iného a, ktorý vidí tá funkcia.

To že si tam potom pridal premennú b nemá žiadny prínos. Iné by to bolo keby ako som spomínal to a bol nejaký komplikovaný objekt. Napríklad to bude excelovský súbor. A ty chceš spočítať priemer v nejakom riadku. Tak aby si nemusel vždy referencovať systémom workBook.worksheet("data").cell(1,0) ....
tak si vytvoríš referenčnú premennú wkSh=woorkBook.worksheet("data")
Teda zase len prekopíruješ odkaz na existujúci objekt do tvojej lokálnej premennej wkSh
a ušetril si pri každom cykle celú tú referenčnú reťaz ktorá samozrejme poriadne zdržuje. Pri jednom čísle to nespoznáš ale keď ich bude par miliónov tak to zbadáš a riadne. Lebo prechádzať zoznamy cez indexy je najhoršie čo len môže byť z pohľadu rýchlosti.

[zen]

Iné by to bolo keby ako som spomínal to a bol nejaký komplikovaný objekt. Napríklad to bude excelovský súbor. A ty chceš spočítať priemer v nejakom riadku. Tak aby si nemusel vždy referencovať systémom workBook.worksheet("data").cell(1,0) ....
tak si vytvoríš referenčnú premennú wkSh=woorkBook.worksheet("data")
Teda zase len prekopíruješ odkaz na existujúci objekt do tvojej lokálnej premennej wkSh

Toto chapem. K+

[peterple]

V prvom rade: Nikomu never.

Podľa mňa by mal mať užívateľ možnosť si zvoliť či chce použivať hodnotu alebo referenciu premennej. Pri hodnotových typoch to ide, máme nato pointery a podobne. Pri referenčných typoch to už nejde, stále sa predáva len odkaz na referenciu. Je to dané aj iným umiestneným týchto typov v pamati. Tiež nechápem, ak program dokáže bez problémov založť novú premennú typu mojej vlastnej
štruktúry alebo poľa, prečo sa nedá jednoducho vytvoriť jej kópia...ale ako vysvetľovali viac skúsený úživatelia, asi to neje také jednoduché...
No nič, ostáva nám sa s tým len zmieriť.

To že sa nedá jednoducho urobiť kópia objektu nie je celkom pravda. Dá sa, ale nie celkom jednoducho. Že to musí ísť je jasné z nasledujúcej úvahy.
Všetky moderné jazyky (JAVA, C#, JavaScript, Python, ....) robia alokáciu dynamických premenných automaticky. To bol totiž zabiják pre programy v C a C++. Buď tam zostávali memory leaky, alebo aplikácia (niekedy aj celý OS) padol na hubu, lebo sa niekto odvolal na premennú ktorá už neexistovala.
Preto sa tak rozmohla tá JAVA lebo perfektne riešila ten druhý problém. Takže princíp hry je asi takýto:

1. nejaké behové prostredie si manažuje pamäť. Má jedno veľké vrece a to volá heap (hromada) Tam vytvára dynamické datové štruktúry.
2. programátor potrebuje vytvoriť dynamický objekt použije na to kľúčové slovo new a meno konštruktora objektu čo potrebuje. V novších jazykoch ani to new už nie je treba. Napíše napr o={color: "red"} a je to.
   Takto si postupne vytvára objekty ako potrebuje. Tie čo nepotrebuje neuvoľňuje z hromady, ale len ruší na ne referencie.
3. Potom niekto komu sa nadáva GC (garbage collector) príde a všetky kusy pamäte na ktoré neukazuje žiadna referencia označí ako voľné. To znamená že ich to behové prostredie môže zase prideliť, keď program volá že chce kus voľnej pamäte na nový objekt. Super, lenže..
4. Takým to hospodárením by sme tú haldu rozorali na stále menšie a menšie voľné bloky. Lebo tie vytvorené objekty nezanikajú v opačnom poradí ako vznikali ale takmer náhodne, ako si želá programátor aplikácie. Vznikne fragmentácia. Niečo podobné ako fragmentácia disku ktorá vznikne mazaním už nepotrebných súborov.
5. No a teraz zrazu treba uložiť do pamäte obrázok veľký jak blázon. Heap je síce poloprázdny ale je tak rozoraný, že súvislá časť takejto veľkej pamäte k dispozícii nie je. Takže by to skončilo hláškou nie je dosť pamäte. Je jasné že čím dlhšie by takýto systém bežal, tým by bolo horšie. Ako je možné že server beží aj roky bez reštartu a dokáže mať stále veľké kusy pamäte keď je to treba?
6. Všetko odrie GC. Okrem toho že vyprázdňuje nepotrebné kusy pamäte. Tak ich dokáže aj defragmentovať. A to sa dá len tak, že objekt ktorý zostal niekde medzi dvomi voľnými kusmi pamäte prekopíruje niekam inam pekne do súvisle obsadenej pamäte
7. V minulosti to robil trocha idiotsky. Pretože zastavil beh všetkých rozbehnutých programov, upratal a potom sa fičalo zase ďalej.
   Potom to robil trocha lepšie a to zastavenie sa dosť zredukovalo.
   No a teraz to dokáže robiť súčasne (konkurentne) za behu ostatných programov. Dosť často sa pritom vyskytuje stav že v pamäti sú dve kópie toho istého objektu, pričom niektoré referencie ukazujú už na ten nový a niektoré ešte stále na ten starý objekt. GC trpezlivo prerába tie staré referencie na tie nové a keď už žiadna stará referencia neexistuje tak ten starý objekt zmaže a tak získa z dvoch kusov pamäte jeden súvislý.

Celá táto vychytávka niečo stojí. Jednak je potrebné pridať do každého objektu jednu ďalšiu referenciu. Teda je o 4 alebo 8 byte väčší. Druhak je pri referencovaní každého prvku objektu treba vykonať o jednu strojovú inštrukciu na vyše (nejakých pár nanosekund). Nuž ale čo by sme neurobili pre používateľov aby im ten telefón neprestal reagovať na 0,3 sekundy.
To potom počuť sopliakov ako vykrikujú že im to laguje.

No a potom so písal že každý objekt má metódu clone ktorá ho dokáže skopírovať. Otázne je len či je to to čo sme chceli (plytké, hlboké). Niektoré objekty to clone majú udržované pri každom dedení. Alebo má objekt na to špéci funkci. Napríklad v javascripte existuje cloneNode() na kopírovanie Node vrátane toho že si môžem vybrať či naklonovať aj všetky child daného Node.

[zen]

Podľa mňa by mal mať užívateľ možnosť si zvoliť či chce použivať hodnotu alebo referenciu premennej.

Asi budes muset hladat. V Python som to nasiel:

Kód: Vybrať všetko

a=[0,0,0]
b=a
print(a,b)
a[0]=1
b[2]=1
print(a,b,a==b)
print("With deepcopy")
a=[0,0,0]
import copy
b=copy.deepcopy(a)
print(a,b)
a[0]=1
b[2]=1
print(a,b,a==b)

Output:

Kód: Vybrať všetko

[0, 0, 0] [0, 0, 0]
[1, 0, 1] [1, 0, 1] True
With deepcopy
[0, 0, 0] [0, 0, 0]
[1, 0, 0] [0, 0, 1] False

[Radus]

...ďakujem za objasnenie problematiky, budem musieť ešte pohľadať.
R.