56. 일반화할 때, 형식 매개변수 제약시키기

일반화 프로그래밍(아래 영상을 참고하여 학습하였습니다.)

https://youtu.be/etvC-lj39ws

ch11 일반화 프로그래밍 (tistory.com) <-같이 참고해서 공부하기 좋은 블로그

 

 

일반화 코드에서 형식을 제약하는 문법은 다음과 같다.

형식 매개변수에 대한 일반화 클래스나 일반화 메소드에 모두 동일하게 사용된다. 

where 형식매개변수 : 제약조건

제약	설명
where T : struct	T는 값 형식
where T : class	T는 참조형식
where T : new()	T는 반드시 매개변수가 없는 생성자가 있어야 한다.
where T : 기반클래스이름	T는 명시한 기반 클래스의 파생클래스여야 한다.
where T : 인터페이스이름	T는 명시한 인터페이스를 반드시 구현해야 한다. 여러 개의 인터페이스를 명시할 수도 있다!
where T : U	T는 또 다른 형식 매개변수 U로부터 상속받은 클래스여야 한다.

 

 

종종 특정 조건을 갖춘 형식에만 대응하는 형식 매개변수가 필요할 때도 있다.

이때, 형식 매개변수의 조건에 제약을 줄 수 있다.

 

MyList<T> 클래스의 형식 매개변수 T에

Myclass로부터 상속받는 형식이어야 할 것, 이라는 제약을 주려면 다음과 같이 클래스 선언문 헤더에 where절을 추가해준다.

class MyList<T> where T : MyClass
{
     //...
}

일반화 메소드

CopyArray<T>()의 형식 매개변수 T에 "값 형식이어야 할 것"이라는 제약은 다음과 같이 줄 수 있다.

void CopyArray<T>(T[] source, T[] target)where T : struct
{
	for(int i=0; i<source.Length; i++) target[i]=source[i];
{

 

제약 조건이 new()와 형식 매개변수 U일 경우에는 다음과 같다.

 

다음 코드의 CreateInstance<T>() 메소드는 기본 생성자를 가진 어떤 클래스의 객체라도 생성해준다.

이 메소드를 호출할 때 기본 생성자가 없는 클래스를 형식 매개변수에 넘기면 컴파일 에러가 뜬다.

public static T CreateInstance<T>() where T : new()
{
     return new T();
}

다음은 상위 코드에서 사용되던 형식 매개변수 U로부터 상속받는 형식으로 제약조건을 주는 예이다.

다음 코드의 CopyArray<T>()는 소속 클래스인 BaseArray<U>의 형식 매개변수 U로부터 T가 상속받아야 할 것을 강제하고 있다. 

class BaseArray<U> where U : Base
{
     public U[] Array{get; set;}
     public BaseArray(int size)
     {
          Array = new U[size];
     }
     public void CopyArray<T>(T[] Source) where T : U
     {
          Source.CopyTo(Array,0);
     }
}

<예제>

using System;
using System.Collections;

namespace ConstraintsOnTypeParameters
{
    class StructArray<T> where T : struct
    {
        public T[] Array { get; set; }
        public StructArray(int size)
        {
            Array = new T[size];
        }
    }
    class Refarray<T> where T : class
    {
        public T[] Array { get; set; }
        public Refarray(int size)
        {
            Array = new T[size];
        }
    }
    class Base { }
    class Derived : Base { }
    class BaseArray<U> where U : Base
    {
        public U[] Array { get; set; }
        public BaseArray(int size)
        {
            Array = new U[size];
        }
        public void CopyArray<T>(T[] Source) where T : U
        {
            Source.CopyTo(Array, 0);
        }
    }
    interface IDictionary1<T> { }
    interface IDictionary2<T> { }

    class SampleClass1<T> where T : IDictionary1<T> { }
    class SampleClass2<T> where T : IDictionary2<T> { }
    class MainApp
    {
        public static T CreateInstance<T>() where T : new()
        {
            return new T();
        }
        static void Main(string[] args)
        {
            // 값 형식 일반화 클래스
            // - struct는 값 형식으로 제안한다.
            // - StructArray<int>()의 인스턴스는 배열의 크기다.
            StructArray<int> a = new StructArray<int>(3);
            a.Array[0] = 0;
            a.Array[1] = 1;
            a.Array[2] = 2;
            //a.Array[3] = 3; 크기가 3인 배열이므로 범위가 넘어가서 에러
            //a.Array[2] = "에러";  int형식으로 선언했으므로 string형식 에러
            Console.WriteLine("--------------------------------");
            Console.WriteLine($"a.Array[0] : {a.Array[0]}");
            Console.WriteLine($"a.Array[1] : {a.Array[1]}");
            Console.WriteLine($"a.Array[2] : {a.Array[2]}");
            Console.WriteLine("--------------------------------");
            Console.WriteLine();

            Refarray<StructArray<double>> b = new Refarray<StructArray<double>>(3);
            b.Array[0] = new StructArray<double>(5);
            b.Array[1] = new StructArray<double>(10);
            b.Array[2] = new StructArray<double>(1005);
            b.Array[0].Array[4] = 3.14d;
            b.Array[1].Array[9] = 2.86d;
            b.Array[2].Array[1004] = 101.1004d;
            Console.WriteLine("--------------------------------");
            Console.WriteLine($"b.Array[0].Array[4] : {b.Array[0].Array[4]}");
            Console.WriteLine($"b.Array[1].Array[9] : {b.Array[1].Array[9]}");
            Console.WriteLine($"b.Array[2].Array[1004] : {b.Array[2].Array[1004]}");
            Console.WriteLine("--------------------------------");
            Console.WriteLine();

            BaseArray<Base> c = new BaseArray<Base>(3);
            c.Array[0] = new Base();
            c.Array[1] = new Derived();
            c.Array[2] = CreateInstance<Base>();
            Console.WriteLine("--------------------------------");
            Console.WriteLine($"c.Array[0] : {c.Array[0]}");
            Console.WriteLine($"c.Array[1] : {c.Array[1]}");
            Console.WriteLine($"c.Array[2] : {c.Array[2]}");
            Console.WriteLine("--------------------------------");
            Console.WriteLine();
            BaseArray<Derived> d = new BaseArray<Derived>(3);
            d.Array[0] = new Derived(); //Base 형식은 여기에 할당할 수 없다.
            d.Array[1] = CreateInstance<Derived>();
            d.Array[2] = CreateInstance<Derived>();
            Console.WriteLine("--------------------------------");
            Console.WriteLine($" d.Array[0] : {d.Array[0]}");
            Console.WriteLine($" d.Array[1] : {d.Array[1]}");
            Console.WriteLine($" d.Array[2] : {d.Array[2]}");
            Console.WriteLine("--------------------------------");
            Console.WriteLine();

            BaseArray<Derived> e = new BaseArray<Derived>(3);
            e.CopyArray<Derived>(d.Array); //e에 다가 d를 덮어씌운다.
            Console.WriteLine($" d.Array : {d.Array}");
        }
    }
}

 

<출력 결과>

--------------------------------
a.Array[0] : 0
a.Array[1] : 1
a.Array[2] : 2
--------------------------------

--------------------------------
b.Array[0].Array[4] : 3.14
b.Array[1].Array[9] : 2.86
b.Array[2].Array[1004] : 101.1004
--------------------------------

--------------------------------
c.Array[0] : ConstraintsOnTypeParameters.Base
c.Array[1] : ConstraintsOnTypeParameters.Derived
c.Array[2] : ConstraintsOnTypeParameters.Base
--------------------------------

--------------------------------
 d.Array[0] : ConstraintsOnTypeParameters.Derived
 d.Array[1] : ConstraintsOnTypeParameters.Derived
 d.Array[2] : ConstraintsOnTypeParameters.Derived
--------------------------------

 d.Array : ConstraintsOnTypeParameters.Derived[]