Как можно избежать огромного количества перегрузок операторов c#?

Question

struct Vector2
{
    public Vector2(float x, float y)
    {
       this.x = x;
       this.y = y;
    }
    public float x;
    public float y;

    public static Vector2 operator+(Vector2 vector2, Vector2 vector21) { return new 
Vector2(vector2.x + vector21.x, vector2.y + vector21.y); }
    public static Vector2 operator/(Vector2 vector2, Vector2 vector21) { return new 
Vector2(vector2.x / vector21.x, vector2.y / vector21.y); }
    public static Vector2 operator*(Vector2 vector2, Vector2 vector21) { return new 
Vector2(vector2.x * vector21.x, vector2.y * vector21.y); }
    public static Vector2 operator-(Vector2 vector2, Vector2 vector21) { return new 
Vector2(vector2.x - vector21.x, vector2.y - vector21.y); }
    public static Vector2 operator +(Vector2 vector2, float number) { return new 
Vector2(vector2.x + number, vector2.y + number); }
    public static Vector2 operator /(Vector2 vector2, float number) { return new 
Vector2(vector2.x / number, vector2.y / number); }
    public static Vector2 operator *(Vector2 vector2, float number) { return new 
Vector2(vector2.x * number, vector2.y * number); }
    public static Vector2 operator -(Vector2 vector2, float number) { return new 
Vector2(vector2.x - number, vector2.y - number); }
   public static Vector2 operator +(float number, Vector2 vector2) { return new 
Vector2(vector2.x + number, vector2.y + number); }
    public static Vector2 operator *(float number, Vector2 vector2) { return new 
Vector2(vector2.x * number, vector2.y * number); }

}

Такой код очень большой и не красивый. Могу ли я сократить его?

Answer 1

И как ты себе это представляешь? Что бы язык сам догадывался какие операции делать?)

Но вообще можно сократить.

Сократить названия переменных: (Vector2 a, Vector2 b)
Использовать стрелочные функции: method() => result
Использовать сокращённый new: Vector2 method() => new(x, y)
using v2 = Vector2
Неявное преобразование (float, float) в Vec2(float, float)

Ну а ещё я добавил немного отсебятины, а именно по 2 вариации для операторов, где важен порядок (такие как vec2 / float и float / vec2)

Ну и добавил первичных конструкторов что бы показать возможности : this()

И добавил неявное преобразование, так как оно тоже иногда полезно

А ещё переопределил метод ToString(), что бы он корректно отображался при Console.WriteLine() и других подобных методов

В целом получается как то так:

using V2 = Vector2;
struct Vector2
{
    public float x;
    public float y;
    public Vector2(float x, float y)
    {
        this.x = x;
        this.y = y;
    }
    public Vector2(float v) : this(v, v) { }
    public Vector2() : this(0) { }

    public override string ToString() => $"({x}, {y})";

    public static implicit operator V2((float x, float y) v) => new(v.x, v.y);

    // По скольку у нас есть неявное преобразование (float, float) в Vec2
    // мы можем не писать new, однако это может ударить по происзводительности
    // public static V2 operator +(V2 a, V2 b) => (a.x + b.x, a.y + b.y);

    // Vec2 . Vec2
    public static V2 operator +(V2 a, V2 b) => new(a.x + b.x, a.y + b.y);
    public static V2 operator -(V2 a, V2 b) => new(a.x - b.x, a.y - b.y);
    public static V2 operator *(V2 a, V2 b) => new(a.x * b.x, a.y * b.y);
    public static V2 operator /(V2 a, V2 b) => new(a.x / b.x, a.y / b.y);
    public static V2 operator %(V2 a, V2 b) => new(a.x % b.x, a.y % b.y);

    // Vec2 . float
    public static V2 operator +(V2 a, float v) => new(a.x + v, a.y + v);
    public static V2 operator -(V2 a, float v) => new(a.x - v, a.y - v);
    public static V2 operator *(V2 a, float v) => new(a.x * v, a.y * v);
    public static V2 operator /(V2 a, float v) => new(a.x / v, a.y / v);
    public static V2 operator %(V2 a, float v) => new(a.x % v, a.y % v);

    // float . Vec2
    public static V2 operator +(float v, V2 a) => new(v + a.x, v + a.y);
    public static V2 operator -(float v, V2 a) => new(v - a.x, v - a.y);
    public static V2 operator *(float v, V2 a) => new(v * a.x, v * a.y);
    public static V2 operator /(float v, V2 a) => new(v / a.x, v / a.y);
    public static V2 operator %(float v, V2 a) => new(v % a.x, v % a.y);

    // . Vec2
    public static V2 operator -(V2 v) => new(-v.x, -v.y);
    public static V2 operator +(V2 v) => v;
}

БЛОГ НА HUSL

Как можно избежать огромного количества перегрузок операторов c#?

Ответы (1 шт):