Başka bir soruyla geleyim;
benim anladığım normal standart yani static diziler kopyalandıklarında ayrı bir değişken gibi işlem görürken, dinamik diziler ise sanki referans gibi işlem görüyor örneğin;
import std.stdio;

void main() {
	int[4] dizi1= [0, 10, 20, 30];
	int[4] dizi2 = dizi1;
	dizi1[1]= 100;
	writeln(dizi1);
	writeln(dizi2);
}
şöyle bir kodu derlediğimizde statik diziler kullanıldığından beklendiği gibi sonuç;

[0, 100, 20, 30]
[0, 10, 20, 30]

çıkacaktır . Ancak referans gibi çalışan Dinamik dizilerde (gibi dememin sebebi hala çözememiş olduğum aşağıdaki konu yüzündedndir yoksa direkt referans diyecektim) şu örnekte;

import std.stdio;

void main() {
	int[] dizi1= [0, 10, 20, 30];
	int[] dizi2 = dizi1;
	dizi1[1]= 100;
	writeln(dizi1);
	writeln(dizi2);
}

madem referans gibi! o halde elbette sonuç;

[0, 100, 20, 30]
[0, 100, 20, 30]

oluyor.. Buraya kadar sorun yok herşey yerli yerinde ancak şunu yaptığım vakit;

import std.stdio;

void main() {
	int[] dizi1= [0, 10, 20, 30];
	int[] dizi2 = dizi1;
	dizi1 ~= 40;
	dizi1[1]= 100;
	writeln(dizi1);
	writeln(dizi2);
}

sonuç;
[0, 100, 20, 30, 40]
[0, 100, 20, 30]

madem referans ise yada referans gibi davranıyorsa dinamik diziler neden dizi1e eklenen eleman dizi2 de gösterilmiyor ?

On 8/15/22 03:50, Cos00kun wrote:

> void main() {
>      int[] dizi1= [0, 10, 20, 30];
>      int[] dizi2 = dizi1;
>      dizi1 ~= 40;
>      dizi1[1]= 100;
>      writeln(dizi1);
>      writeln(dizi2);
> }
>
> sonuç;
> [0, 100, 20, 30, 40]
> [0, 100, 20, 30]
>
> madem referans ise yada referans gibi davranıyorsa dinamik diziler neden
> dizi1e eklenen eleman dizi2 de gösterilmiyor ?

Bunun yanıtını görmek için bir gözlem sunacağım ve başka bir soru soracağım.

Gözlem: Aslında dizi1 ve dizi2 dinamik dizi değildirler, dilimdirler (slice). Evet, olayın arkasında dinamik dizi(ler) vardır ama o diziler D runtime (veya çöp toplayıcı (GC)) denen bir varlık tarafından sahiplenilmiş olan ve isimleri olmayan eleman topluluklarıdır. Dilimler, o elemanlara erişim sağlarlar; yani, eleman referanslarıdır.

Bence referans konusu öylece açıklanıyor.

Şimdi başka bir soru:

import std.stdio;

void main() {
  int[] d = [ 1, 2, 3, 4 ];
  int[] başı = d[0..$/2];
  int[] sonu = d[$/2..$];

  writeln(başı);  // [1, 2]
  writeln(sonu);  // [3, 4]
}

Peki, `başı ~= 100` yaptığımızda ne olsun? Seçenekler:

a) Nasıl olsa referans olduklarından, bir sonraki elemanın üstüne yazılsın:

başı: [ 1, 2, 100 ]      <-- başı uzadı
d:    [ 1, 2, 100, 4 ]      <-- 3'ün üzerine yazıldı
sonu: [ 100, 4]          <-- 3'ün üzerine yazıldı

(O galiba C#'ın seçtiği yöntemmiş.)

b) Varolan elemanlar korunsunlar ve yeni dilim yepyeni elemanlar edinsin. Bu da D'nin seçimi... Bunun adına "no stomping" deniyor. Yani, varolan elemanların üzerine yazılmıyor:

başı: [ 1, 2, 100 ]      <-- Yepyeni adresteler
d:    [ 1, 2, 3, 4 ]     <-- Korunmuş
sonu: [ 3, 4 ]           <-- Korunmuş

Ali

On 8/15/22 03:50, Cos00kun wrote:
> Başka bir soruyla geleyim;

Bence konular böyle uzatılırsa yararları azalıyor. Örneğin, bu yeni sorunun "Dizilerde karışık türler" ile ilgisi yok. ;)

Ali

On Monday, 15 August 2022 at 14:15:05 UTC, Ali Çehreli wrote:
>
> (O galiba C#'ın seçtiği yöntemmiş.)
>
> b) Varolan elemanlar korunsunlar ve yeni dilim yepyeni elemanlar edinsin. Bu da D'nin seçimi... Bunun adına "no stomping" deniyor. Yani, varolan elemanların üzerine yazılmıyor:
>
> başı: [ 1, 2, 100 ]      <-- Yepyeni adresteler
> d:    [ 1, 2, 3, 4 ]     <-- Korunmuş
> sonu: [ 3, 4 ]           <-- Korunmuş
>
> Ali

Hmmm tamamra ali hocam anladım. Benim hatam o dilimlere referans gibi davranmak olmuş. Yan ali ye MehmetAli demiş gibi oldum.

On Monday, 15 August 2022 at 14:16:25 UTC, Ali Çehreli wrote:
> On 8/15/22 03:50, Cos00kun wrote:
> > Başka bir soruyla geleyim;
>
> Bence konular böyle uzatılırsa yararları azalıyor. Örneğin, bu yeni sorunun "Dizilerde karışık türler" ile ilgisi yok. ;)
>
> Ali


Anlaşıldı. Ben buradaki forum düzenine henüz alışamadım ama dediğin doğru Ali hocam. Tamamdır