Merhaba,

Temel türler ile dizilerde seri çarpma işlemi yapabiliyoruz ama kendi türümde nasıl yapabileceğimi çözemedim. Şurada bir şeyler yazıyor ama örnek bulamadım:

https://dlang.org/spec/operatoroverloading.html#slice_op_assignment

Acaba aşağıda gizlediğim satırı yapmanın bir yolu var mı?

import std.stdio;

struct Payload {
  int quantity;

  void opOpAssign(string op: "*")(int rhs)
  {
    quantity *= rhs;
  }
}

enum test = 10;

void main()
{
  int i = test;
  auto n = new int[test];
  auto p = Payload(test);
  auto payloads = new Payload[test];

  p *= 2;
  i *= 2;
  assert(p.quantity == i);

  foreach(num, ref e; n)
  {
    e = cast(int)num + 1;
    payloads[num].quantity = e;
  }
  payloads.writeln;
  n[] *= 2;
  n.writeln;
  //payloads[] *= 2;
}

Teşekkürler...

SDB@79

On Saturday, 16 September 2023 at 18:23:10 UTC, Salih Dincer wrote:

Ali hoca 2 sene önce bu konuya bir cevap yazmış:

https://forum.dlang.org/post/sh3bh9$10vo$1@digitalmars.com

Ama benim ki Object'den türeyen bir dizi. Diğer başlıkta dizi aslında yapının bir elemanı!

On Saturday, 16 September 2023 at 18:23:10 UTC, Salih Dincer wrote:

İşte örnek: https://run.dlang.io/is/08iBAQ

Aynı olanağı kullanmadım çünkü 2 sene önce soruyu soran da cevaplayan da işaretçiler ile aslında harika bir çözüm sunmuş. Ben sadece biraz rötuşladım ama henüz bunu kendi türüme uygulamadım ki bu artık mümkün görünüyor...😎

Bu arada, aşağıda alias this = ... yerine auto opIndex() => this;` kullanılmış olmasına dikkat edin. Ayrıca new operatörüne overload yapamadığımız için, hemen altına mecbur 2. bir kurucu üye ekledim. Böylece daha kısa veya paylaşımlı kullanımlar mümkün. Bu basitlik sanırım libmir'de bile yok!

struct Array(T)
{
  T* ptr;
  auto opIndex() => this;

  size_t length;
  auto opDollar() => length;

  this(size_t length)
  {
    this.ptr = new T[length].ptr;
    this.length = length;
  }

  this(T* ptr, size_t length)
  {
    this.ptr = ptr;
    this.length = length;
  }

  ref T opIndex(size_t i) => ptr[i];
  auto opSlice(size_t beg, size_t end)
    => Array(&ptr[beg], end - beg);

  void opOpAssign(string op)(T rhs)
  if((op == "+") || (op == "*"))
  {
    foreach(i; 0..length)
    {
      mixin("ptr[i] " ~ op ~ "= rhs;");
    }
  }

  alias ToSink = void delegate(const(char)[]);
  void toString(ToSink sink) const
  {
    import std.format: fmt = formattedWrite;
    sink("[");
    const limit = length - 1;
    foreach(i; 0..limit)
    {
      sink.fmt("%s, ", ptr[i]);
    }
    sink.fmt("%s]", ptr[limit]);
  }
}

enum test = 10;
import std.stdio;

void main()
{
  // EN KISA KURULUM:
  auto arr = Array!int(test);

  foreach(i; 0..test) arr[i] = i + 1;
  arr.writeln; // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  arr[] += 1;  // tüm üyelere birer ekle
  arr.writeln; // [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

  arr[] *= 2;  // tüm üyeleri ikiye katla
  arr.writeln; // [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]


  // PARALEL KURULUM (paylaşımlı):
  auto n = new int[test];
  auto p = Array!int(n.ptr, test);

  foreach(num, ref e; n)
  {
    e = cast(int)num + 1;
  }
  p.writeln; // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  n[] *= 2;
  n.writeln; // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

  p[] *= 2;
  n.writeln; // [4, 8, 12, 16, 20, 24, 28, 32, 36, 40]

  n[4..$].writeln; // [20, 24, 28, 32, 36, 40]
  p[4..$].writeln; // [20, 24, 28, 32, 36, 40]
}

SDB@79