• - tank, bana once kosedeki durumcuden bi urfa; donerken bakkaldan iki paket kisa maltepe, bi ufak raki kap. yengenle alem var bu aksam. sonra su geminin yerlerini bi sil bakiim; bok goturuyor her yeri be. ha hazir baslamisken benim carsaflari da bi yikayiver; yengenle alem vardi dun aksam. tamam mi kocum. ha, unutmadan, bi de en yakin cikisi bul bana. hadi bakiim.
    - operator overloading - system crash...
    - tank?
  • (bkz: operation overlord)
  • c# (bkz: c sharp)'ta şu şekilde daha iyidir;

    class anik
    {
    public int x;
    public anik(int i)
    {
    this.x = i;
    }
    public static anik operator +(anik a, anik b)
    {
    return new anik(a.x + b.x);
    }
    }
  • bu işi çoluğun çocuğun eline bırakırsanız vahim durumlarla karşılaşabilirsiniz. operator overloading sayesinde zira elma ve armut da toplanabilmekte. kodu okuyan zata da bu hiç birşey ifade etmemektedir. matematiksel işlemler için biçilmiş kaftan (ozellikle matris hesaplarında) olmakla birlikte bunun dışında çok dikkatli ve bilinçli bir şekilde kullanılması tavsiye olunur.
    araba= şasi+(4*lastik).... gibi bir ifade her ne kadar hoş görünse de (vallahi şimdi aklıma geldi) tasvip ettiğim bir uslup değildir.
  • komplex sayilarla ilgili islemleri dort isleme cevirmeye yarayan hede.

    c#* ta bir ornek vermek istersek;

    using system;

    public class complexnumber
    {
    private double real;
    private double imaginary;

    public complexnumber(double a, double b)
    {
    real = a;
    imaginary = b;
    }

    public double real
    {
    get { return real; }
    set { real = value; }
    }
    public double imaginary
    {
    get { return imaginary; }
    set { imaginary = value; }
    }

    public static complexnumber operator +(complexnumber x, complexnumber y)
    {
    return new complexnumber(x.real + y.real, x.imaginary + y.imaginary);
    }
    public static complexnumber operator -(complexnumber x,complexnumber y)
    {
    return new complexnumber(x.real - y.real, x.imaginary - y.imaginary);
    }
    public static complexnumber operator *(complexnumber x, complexnumber y)
    {
    return new complexnumber(x.real * y.real - x.imaginary * y.imaginary,
    x.imaginary * y.real + x.real * y.imaginary);
    }
    public static complexnumber operator /(complexnumber x, complexnumber y)
    {
    double denominator = (y.real * y.real + y.imaginary * y.imaginary);
    return new complexnumber((x.real * y.real + x.imaginary * y.imaginary) / denominator,
    (x.imaginary * y.real - x.real * y.imaginary) / denominator);
    }

    public override string tostring()
    {
    if (real == 0 && imaginary == 0)
    return "0";
    else if (real == 0)
    {
    string sign = getimaginarysign();
    return string.format("({0}{1}i)", (sign == "+" ? "" : sign), getimaginaryasstring());
    }
    else if (imaginary == 0)
    return string.format("({0})", real);
    else
    return string.format("({0} {1} {2}i)",
    real, getimaginarysign(), getimaginaryasstring());
    }

    private string getimaginaryasstring()
    {
    double i = math.abs(imaginary);
    return (i == 1 ? "" : convert.tostring(i));
    }

    private string getimaginarysign()
    {
    return (imaginary < 0 ? "-" : "+");
    }

    }

    birde ornek kullanim yazalim;

    using system;

    class test
    {
    static void main()
    {
    complexnumber z1 = new complexnumber(1, 3);
    complexnumber z2 = new complexnumber(2, 2);

    console.writeline("{0} + {1} = {2}", z1, z2, z1 + z2);
    console.writeline("{0} - {1} = {2}", z1, z2, z1 - z2);
    console.writeline("{0} * {1} = {2}", z1, z2, z1 * z2);
    console.writeline("{0} / {1} = {2}", z1, z2, z1 / z2);

    }
    }

    (bkz: sozlugu msdn e cevirmek)
  • bir programlama dilinde, bir operator gibi temel matematik işlemin, dildeki ana tanımlarının dışında kullanılması. nesne yönelimli programlamanın temel yapıtaşlarından polimorfizmin özel bir türüdür.

    bir operatorün kendi tanımının dışında kullanılabilmesi için gerekli bilgiler programlama dilinde olabileceği gibi, bir kütüphane şeklinde de olabilir. örneğin vhdl dilinde "*" işlemi numeric_std kütüphanesinde overload edilmiştir ( http://www.csee.umbc.edu/…elp/vhdl/numeric_std.vhdl ):

    -- id: a.15
    function "*" (l, r: unsigned) return unsigned;
    -- result subtype: unsigned((l'length+r'length-1) downto 0).
    -- result: performs the multiplication operation on two unsigned vectors
    -- that may possibly be of different lengths.

    -- id: a.16
    function "*" (l, r: signed) return signed;
    -- result subtype: signed((l'length+r'length-1) downto 0)
    -- result: multiplies two signed vectors that may possibly be of
    -- different lengths.

    -- id: a.17
    function "*" (l: unsigned; r: natural) return unsigned;
    -- result subtype: unsigned((l'length+l'length-1) downto 0).
    -- result: multiplies an unsigned vector, l, with a non-negative
    -- integer, r. r is converted to an unsigned vector of
    -- size l'length before multiplication.

    -- id: a.18
    function "*" (l: natural; r: unsigned) return unsigned;
    -- result subtype: unsigned((r'length+r'length-1) downto 0).
    -- result: multiplies an unsigned vector, r, with a non-negative
    -- integer, l. l is converted to an unsigned vector of
    -- size r'length before multiplication.

    -- id: a.19
    function "*" (l: signed; r: integer) return signed;
    -- result subtype: signed((l'length+l'length-1) downto 0)
    -- result: multiplies a signed vector, l, with an integer, r. r is
    -- converted to a signed vector of size l'length before
    -- multiplication.

    -- id: a.20
    function "*" (l: integer; r: signed) return signed;
    -- result subtype: signed((r'length+r'length-1) downto 0)
    -- result: multiplies a signed vector, r, with an integer, l. l is
    -- converted to a signed vector of size r'length before
    -- multiplication.

    yukarıda * operatörü bir fonksiyon gibi 6 kere tanımlanmıştır. aynı fonksiyon 6 kere tanımlanmış ancak her bir tanım farklı amaçlar için tanımlanmıştır. farklı oldukları nokta, argümanların türüdür.

    eğer yukarıdaki operatör overloading fonksiyonlarından sadece a15'te belirtilen tanım olsaydı ve vhdl programımızda iki tane signed türden değişkeni çarpmak isteseydik, o zaman şöyle yazmak zorunda kalacaktık:

    signal a : signed (7 downto 0);
    signal b : signed (7 downto 0);
    signal c : signed (15 downto 0);

    c <= signed ((unsigned) (a) * (unsigned) (b));

    görüldüğü gibi, sadece bir çarpma işlemi için 3 kere type casting yapmak zorunda kalıyoruz. yukarıdaki 6 operator overloading sayesinde değişken türlerini bilmeden doğrudan çarpabiliyoruz:

    c <= a * b;

    görüldüğü gibi kod daha temiz ve kolay anlaşılır duruyor.

    polimorfizmin, işleri ne kadar kolaylaştırdığını gösteren güzel bir örneğidir.

    edit: vhdl programlama dilinde ieee.std_logic_arith kütüphanesi synopsys firması tarafından geliştirilmiştir. standard değildir. signed/unsigned konusundaki işlemler ve diğer şeyler için sadece ve sadece ieee.numeric_std kütüphanesi kullanılmalıdır, zira bu kütüphane ieee standardıdır.
  • bunun parantez overload'u vardır bir de.
    struct foo
    {
    void operator()() {
    std::cout << "merhabalar!" << std::endl;
    }
    };

    tarzında yaratılan bir structtan obje yarattıktan sonra

    foo object;
    object(); işlemi yapılarak çalıştırılabilir.
    parantez overload genel olarak c++'ta functors için kullanılır. kodu okurken sadece bir nesne yaratılmış gibi görürsünüz fakat arkada overloadlanan fonksiyonun içinde onlarca hesaplama yapılmış olabilir. okuması ve takip etmesi open source'taki en zor şeylerden biridir. (c++ için)
  • çok spesifik bazı durumlar dışında ihtiyacım olmayan, olsa da kullanmaktan kaçındığım bir pattern, özellik her ne skimse öyle bir şeydir.

    point3d + vector3d aslında çok doğal olarak basit bir vektör operasyonu gibi duruyor ama bunu operator overloading ile yapınca anlaması zorlaşıyor. point3d.translate/move(vector3d) gibi bir metot hem işimizi görüyor hem de kütüphane ya da class apisine uzak olan arkadaşlarımızın da çok çabuk "aa evet bu point3d'yi verilen vector3d kadar taşıyacağım" fikrini edinebiliyor.
  • c++'da kullanımı beyledir:

    #include <iostream>
    using namespace std;
    class complex {
    public:
    double gercek, sanal;
    complex(double g, double s) {
    this->gercek = g;
    this->sanal = s;
    }
    complex operator+(complex &c) {
    return complex(this->gercek + c.gercek, this->sanal + c.sanal);
    }
    complex operator-(complex &c) {
    return complex(this->gercek - c.gercek, this->sanal - c.sanal);
    }
    };

    int main() {
    complex c1(1, 0), c2(10, -4), c3 = c1 + c2, c4 = c1 - c2;
    cout << c3.gercek << " " << c3.sanal << endl;
    cout << c4.gercek << " " << c4.sanal << endl;
    }
hesabın var mı? giriş yap