구조체와 연산자 오버로딩

// 클래스(참조 타입)와 구조체(값 타입)의 차이 예시
PointClass c1 = new PointClass();
c1.X = 10;

PointClass c2 = c1;      // 가리키는 자리가 복사됨
c2.X = 99;

Console.WriteLine($"클래스  c1.X = {c1.X}, c2.X = {c2.X}");

PointStruct s1 = new PointStruct();
s1.X = 10;

PointStruct s2 = s1;     // 내용이 복사됨
s2.X = 99;

Console.WriteLine($"구조체  s1.X = {s1.X}, s2.X = {s2.X}");

class PointClass
{
    public int X;
}

struct PointStruct
{
    public int X;
}

// 매개변수일 때 클래스(참조 타입)와 구조체(값 타입)의 차이 예시
PointClass c = new PointClass();
c.X = 10;
ChangeClass(c);
Console.WriteLine($"클래스  {c.X}");

PointStruct s = new PointStruct();
s.X = 10;
ChangeStruct(s);
Console.WriteLine($"구조체  {s.X}");

void ChangeClass(PointClass p)
{
    p.X = 99;
}

void ChangeStruct(PointStruct p)
{
    p.X = 99;
}

class PointClass
{
    public int X;
}

struct PointStruct
{
    public int X;
}

// 배열의 요소일 때 클래스(참조 타입)와 구조체(값 타입)의 차이 예시
// 구조체 배열 — 요소가 이미 자리를 잡고 있음
PointStruct[] structs = new PointStruct[3];
structs[0].X = 7;
Console.WriteLine($"구조체 배열  {structs[0].X}, {structs[1].X}");

// 클래스 배열 — 요소가 아직 아무것도 가리키지 않음
PointClass[] classes = new PointClass[3];
Console.WriteLine($"클래스 배열  {(classes[0] == null ? "빈 자리" : "객체 있음")}");

classes[0] = new PointClass();
classes[0].X = 7;
Console.WriteLine($"클래스 배열  {classes[0].X}");

struct PointStruct
{
    public int X;
}

class PointClass
{
    public int X;
}

flowchart LR
    subgraph 스택
        S1["s1 : PointStruct X = 10"]
        S2["c1 : 참조"]
    end

    subgraph 힙
        H1["PointClass X = 99"]
    end

    S2 --> H1

// 구조체 선언 예시
Point p = new Point();
p.X = 100;
p.Y = 200;

struct Point
{
    public int X;
    public int Y;
}

// new 없이 선언하는 예시
Point p;
p.X = 100;
p.Y = 200;

Console.WriteLine($"({p.X}, {p.Y})");

struct Point
{
    public int X;
    public int Y;
}

// 구조체 생성자 사용 예시
struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

// 구조체 생성자중 빠진 필드에 값을 넣어주는 예시
struct Point
{
    public int X;
    public int Y;

    public Point(int x)
    {
        X = x;
        Y = 0;          // 남는 필드도 채움
    }
}

// ToString() 재정의 예시
Point p = new Point(3, 7);

Console.WriteLine(p);
Console.WriteLine($"위치는 {p}");

struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

// 구조체로 묶는 예시
Score[] scores =
{
    new Score("홍길동", 100, 90),
    new Score("백두산", 90, 80),
    new Score("임꺽정", 80, 70)
};

Console.WriteLine("이름     국어  영어  총점  평균");

foreach (Score s in scores)
{
    Console.WriteLine($"{s.Name}  {s.Korean,4}  {s.English,4}  {s.Total,4}  {s.Average,5:F1}");
}

struct Score
{
    public string Name;
    public int Korean;
    public int English;

    public Score(string name, int korean, int english)
    {
        Name = name;
        Korean = korean;
        English = english;
    }

    public int Total => Korean + English;
    public double Average => Total / 2.0;
}

// 박싱과 언박싱이 발생하는 예시
Point p = new Point(3, 4);

object boxed = p;              // 박싱 — 힙에 복사본이 만들어짐
Console.WriteLine(boxed);

Point back = (Point)boxed;     // 언박싱 — 타입을 적어 값을 꺼냄
Console.WriteLine(back.X + back.Y);

struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

// operator 사용하여 +를 재정의하고 override로 ToString()을 재정의 하는 예시
struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    // + 연산자 정의
    public static Point operator +(Point left, Point right)
    {
        return new Point(left.X + right.X, left.Y + right.Y);
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

// Point * int
public static Point operator *(Point point, int factor)
{
    return new Point(point.X * factor, point.Y * factor);
}

// int * Point — 순서를 바꿔 쓸 수 있게 따로 정의함
public static Point operator *(int factor, Point point)
{
    return point * factor;
}

a == b : True
a != c : True
a.Equals(b) : True
해시가 같은가 : True

using System;

Point p = new Point(1, 2);
Console.WriteLine(p);

p += new Point(3, 4);        // + 만 정의했는데 += 가 동작함
Console.WriteLine(p);

p += new Point(10, 10);
Console.WriteLine(p);

struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public static Point operator +(Point left, Point right)
    {
        return new Point(left.X + right.X, left.Y + right.Y);
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

(1, 2)
(4, 6)
(14, 16)

// implicit 사용 예시
struct Celsius
{
    public double Degrees;

    public Celsius(double degrees)
    {
        Degrees = degrees;
    }

    // Celsius → double
    public static implicit operator double(Celsius celsius)
    {
        return celsius.Degrees;
    }

    // double → Celsius
    public static implicit operator Celsius(double degrees)
    {
        return new Celsius(degrees);
    }
}

// explicit 사용 예시
struct Celsius
{
    public double Degrees;

    public Celsius(double degrees)
    {
        Degrees = degrees;
    }

    // Celsius → Fahrenheit
    public static explicit operator Fahrenheit(Celsius celsius)
    {
        return new Fahrenheit(celsius.Degrees * 9 / 5 + 32);
    }

    // Fahrenheit → Celsius
    public static explicit operator Celsius(Fahrenheit fahrenheit)
    {
        return new Celsius((fahrenheit.Degrees - 32) * 5 / 9);
    }

    public override string ToString()
    {
        return $"{Degrees}°C";
    }
}

// 잘못 사용하는 예시. 이렇게 쓰지 않음 — 기호는 + 인데 동작은 뺄셈임
public static Point operator +(Point left, Point right)
{
    return new Point(left.X - right.X, left.Y - right.Y);
}

// 새 값을 만들어 돌려주는 예시
public static Point operator +(Point left, Point right)
{
    return new Point(left.X + right.X, left.Y + right.Y);
}