#define SOL_ALL_SAFETIES_ON 1

#include <sol/sol.hpp>
#include <assert.hpp>

int main() {
	sol::state lua;
	int x = 0;
	lua.set_function("beep", [&x]{ ++x; });
	lua.script("beep()");
	c_assert(x == 1);

	sol::function beep = lua["beep"];
	beep();
	c_assert(x == 2);

	return 0;
}

#define SOL_ALL_SAFETIES_ON 1

#include <sol/sol.hpp>
#include <assert.hpp>

struct vars {
	int boop = 0;

	int bop () const {
		return boop + 1;
	}
};

int main() {
	sol::state lua;
	lua.new_usertype<vars>("vars", 
		"boop", &vars::boop,
		"bop", &vars::bop);
	lua.script("beep = vars.new()\n"
		"beep.boop = 1\n"
		"bopvalue = beep:bop()");

	vars& beep = lua["beep"];
	int bopvalue = lua["bopvalue"];

	c_assert(beep.boop == 1);
	c_assert(lua.get<vars>("beep").boop == 1);
	c_assert(beep.bop() == 2);
	c_assert(bopvalue == 2);

	return 0;
}

ref : https://sol2.readthedocs.io/en/latest/

ref : https://blog.naver.com/sheld2/222654277182

td::forward가 가장 많이 쓰이는 곳은 보편 참조 매개변수로 받아서 처리하는 로직입니다.

// lvalue를 캐치하는 함수
void Catch(Person& p, const char* name)
{
    cout << name << "lvalue catch" << endl;
}

// rvalue를 캐치하는 함수
void Catch(Person&& p, const char * name)
{
    cout << name << "rvalue catch" << endl;
}

// 전달받은 obj를 std::forward를 통해서 catch 함수로 전달합니다.
template<typename T>
void ForwardingObj(T&& obj, const char* name)
{
    Catch(std::forward<T>(obj), name);
}

int _tmain(int argc, _TCHAR* argv[])
{
    Person p1("ahn", 1985);
    ForwardingObj(p1, "p1\t\t=\t");
    ForwardingObj(std::move(p1), "std::move(p1)\t=\t");

    return 0;
}

수행결과

ref : https://jungwoong.tistory.com/53

Consumer는 1개의 Type T 인자를 받고 리턴 값이 없는 함수형 인터페이스입니다.

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

}

Example 1 : Consumer

Consumer는 Lambda 표현식으로 구현할 수 있습니다. accept() 호출과 함께 인자를 전달하면 구현된 내용이 수행됩니다.

import java.util.function.Consumer;

public class ConsumerExample1 {

    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.println(s.toUpperCase());

        consumer.accept("hello world");
    }
}

Output:

HELLO WORLD

Example 2 : Primitive Consumer

Java는 Primitive type에 대한 Consumer 클래스를 제공합니다. IntConsumer 외에 DoubleConsumer, LongConsumer가 있습니다.

import java.util.function.IntConsumer;

public class ConsumerExample2 {

    public static void main(String[] args) {
        IntConsumer consumer = n -> System.out.println(n * 100);

        consumer.accept(5);

        consumer.accept(10);
    }
}

Output:

500
1000

Example 3 : List.forEach()

List.forEach()는 인자로 Consumer를 받습니다.

다음과 같이 Consumer를 이용하여 List의 모든 아이템들을 출력할 수 있습니다.

Output:

APPLE
KIWI
ORANGE

Example 4 : andThen()

andThen()은 Consumer들을 연결해주는 Chaining 메소드입니다.

아래 코드에서 addNumber.andThen(printList).accept(fruits)를 호출하면 addNumber()가 수행된 이후에 printList()가 수행됩니다. 두개의 메소드로 전달되는 인자는 fruits로, 동일한 객체가 전달됩니다.

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample4 {

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "kiwi", "orange");

        Consumer<List<String>> addNumber = list -> {
            for (int i = 0; i < list.size(); i++) {
                list.set(i, (i + 1) + ". " + list.get(i));
            }
        };

        Consumer<List<String>> printList = list -> {
            for (String fruit : list) {
                System.out.println(fruit);
            }
        };

        addNumber.andThen(printList).accept(fruits);
    }
}

Output:

1. apple
2. kiwi
3. orange

실제로 andThen()은 아래처럼 구현되어있습니다.

// Consumer.java
public interface Consumer<T> {
  ...
  default Consumer<T> andThen(Consumer<? super T> after) {
      Objects.requireNonNull(after);
      return (T t) -> { accept(t); after.accept(t); };
  }
}

Example 5 : 함수의 인자로 Consumer 전달 (Higher Order Function)

다음과 같이 Consumer를 인자로 받는 함수를 정의할 수 있습니다.

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample5 {

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "kiwi", "orange");

        Consumer<String> printFruit = fruit -> System.out.println("I like " + fruit);

        forEach(fruits, printFruit);
    }

    static <T> void forEach(List<T> list, Consumer<T> consumer) {
        for (T t : list) {
            consumer.accept(t);
        }
    }

}

Output:

I like apple
I like kiwi
I like orange

ref : https://codechacha.com/ko/java8-consumer-example/

그림 1은 런타임 라이브러리 종속 항목을 가진 앱을 보여줍니다. 앱 코드를 검사하는 동안 R8은 MainActivity.class 진입점에서 foo(), faz(), bar() 메서드에 연결할 수 있다고 판단합니다. 그러나 런타임에 OkayApi.class 클래스 또는 baz() 메서드가 앱에서 전혀 사용되지 않으며 R8은 앱을 축소할 때 이 코드를 삭제합니다.

R8은 프로젝트의 R8 구성 파일의 -keep 규칙을 이용하여 진입점을 결정합니다. 즉, keep 규칙은 앱을 축소할 때 R8이 삭제하면 안 되는 클래스를 지정하고 R8은 이 클래스를 앱의 진입점으로 사용할 수 있다고 간주합니다. Android Gradle 플러그인과 AAPT2는 앱의 활동, 보기 및 서비스와 같이 대부분의 앱 프로젝트에서 필요한 keep 규칙을 자동으로 생성합니다. 그러나 추가적인 keep 규칙을 사용하여 이 기본 동작을 맞춤설정해야 하는 경우 유지할 코드를 맞춤설정하는 방법에 관한 섹션을 참조하세요.

대신 앱 리소스의 크기를 줄이는 데만 관심이 있다면 리소스 축소 방법에 관한 섹션을 참조하세요.

유지할 코드 맞춤설정

대부분의 상황에서는 기본 ProGuard 규칙 파일(proguard-android- optimize.txt)만 있으면 R8을 이용하여 미사용 코드를 삭제할 수 있습니다. 그러나 R8에서 정확하게 분석하기 어려운 상황도 있으며 실제로 앱에서 사용하는 코드를 삭제하는 경우도 발생할 수 있습니다. 다음은 코드를 잘못 삭제할 수 있는 몇 가지 예입니다.

• 앱이 자바 네이티브 인터페이스(JNI)에서 메서드를 호출하는 경우
• 앱이 런타임에 리플랙션 등을 사용하여 코드를 찾는 경우

앱을 테스트하면 잘못된 코드 삭제로 인한 오류가 나타나지만 삭제된 코드 보고서를 생성하여 삭제된 코드를 검사할 수도 있습니다.

오류를 수정하고 R8이 특정 코드를 유지하도록 하려면 ProGuard 규칙 파일에 -keep 줄을 추가합니다. 예:

-keep public class MyClass

또는 유지하려는 코드에 @Keep 주석을 추가할 수 있습니다. @Keep을 클래스에 추가하면 전체 클래스가 그대로 유지됩니다. 이 주석을 메서드나 필드에 추가하면 메서드/필드 및 그 이름뿐만 아니라 클래스 이름도 그대로 유지됩니다. 참고로 이 주석은 축소 사용 방법에 관한 섹션에 설명한 대로 AndroidX 주석 라이브러리를 사용하고 Android Gradle 플러그인과 함께 패키징된 ProGuard 규칙 파일을 포함할 때만 사용할 수 있습니다.

-keep 옵션을 사용하려면 고려해야 하는 사항이 많습니다. 규칙 파일을 맞춤설정하는 방법에 관한 자세한 정보는 ProGuard 설명서를 참조하세요. 문제 해결 섹션에서는 코드를 제거할 때 발생할 수 있는 다른 일반적인 문제를 간략히 설명합니다.

ref : https://developer.android.com/studio/build/shrink-code?hl=ko

ref : https://www.youtube.com/watch?v=VUh_t_j9qjE&list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp&index=171

TreeSet 에서  비교 클래슬를 생성자에서 받을때는 Comparable 을 상속받은 클래스는 불가하고

Comparator 를 상속받은 클래스를 생성자에 Functor 식으로 넣어서 비교기준으로 삼는 것은 가능하다

class TestCopmp implements Comparator {

    public int a;

    @Override
    public int compare(Object o1, Object o2) {
        return ((Test)o1).a - ((Test)o2).a;
    }
}

Set set = new TreeSet( new TestCopmp() );

마치 C++ 에서 Fuctor 를 만든것 처럼 끝 어미도 tor 이다, 사용법도 유사하다 볼수 있다

Comparator 는 sort 시에도 정렬 기준으로 던져줄수 있는 Fuctor 다

위 처럼 생성자에 넣는 것이 아닌 클래스 자체에 비교 함수를 override 하는 방법이 있는데 그것이 Comparable 이다

class Test implements Comparable {
    public int a;

    @Override
    public int compareTo(Object o) {
        return a - ((Test)o).a;
    }
}

//원소 추가함과 동시에 정렬됨
Set set = new TreeSet();

for (int i=0; set.size() < 6;++i)
{
    int nm = (int)(Math.random()* 45) + 1;
    Test ss= new Test();
    ss.a = nm;

    set.add(ss);

}

 위 처럼 하면 가능 하지만 Test 클래스가 Comparator 를 상속을 받는것은 가능하나
 객체간의 비교로 사용용도로 사용되진 못한다, 사용하면 크래쉬 (Comparable 로 캐스팅 하지 못한다는 에러 발생)

Exception in thread "main" java.lang.ClassCastException: class Test cannot be cast to 
class java.lang.Comparable (Test is in unnamed module of loader 'app'; 
java.lang.Comparable is in module java.base of loader 'bootstrap')

	at java.base/java.util.TreeMap.compare(TreeMap.java:1563)
	at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:768)
	at java.base/java.util.TreeMap.put(TreeMap.java:777)
	at java.base/java.util.TreeMap.put(TreeMap.java:534)
	at java.base/java.util.TreeSet.add(TreeSet.java:255)
	at comp.main(comp.java:98)

[Comparable 의 사용 예시]

import java.util.*;

//하나의 자바 소스 파일에 작성된 클래스 중 오직 한 클래스만 public으로 선언할 수 있습니다.

//Comparable 상속받아 정렬 기준을 만들수 있다
class Player implements Comparable<Player>
{
    private String name;
    private int score;

    public int getScore(){ return score; }

    @Override
    public int compareTo(Player o) {
        return o.getScore() - this.getScore();
    }

    public Player(String name, int score)
    {
        this.name = name;
        this.score = score;
    }
}

public class comp {

    public static void main(String[] args)
    {
        List<Player> players = new ArrayList<>();
        players.add(new Player("Alice", 899));
        players.add(new Player("Bob", 982));
        players.add(new Player("Chloe", 1090));
        players.add(new Player("Dale", 982));
        players.add(new Player("Eric", 1018));

        //이때 Comparable 이 사용됨
       주석 제거하면 Comparable 가 작동하여 정렬된다
        //Collections.sort(players);


        //comparator 를 통해 클래스 밖에서 정렬 기준을 다르게 하여 정렬 할수 있다
        Comparator<Player> comparator = new Comparator<Player>() {
            @Override
            public int compare(Player a, Player b)
            {
                return a.getScore() - b.getScore();
            }
        };

        //Collection<Integer> sdf = new LinkedList<>();
        Collections.sort(players, comparator);


    }

}

Comparable 인터페이스

객체의 정렬 기준을 정의하는 첫번째 방법은 정렬 대상 클래스를 자바에서 기본적으로 제공하고 있는 Comparable 인터페이스를 구현하도록 변경하는 것입니다. 이를 적용하면 Player 클래스는 다음과 같이 수정됩니다.

public class Player implements Comparable<Player> {
    // Fields, Getters, Setters 생략

    @Override
    public int compareTo(Player o) {
        return o.getScore() - getScore();
    }
}

Comparable 인터페이스의 compareTo() 메서드를 통해 인자로 넘어온 같은 타입의 다른 객체와 대소 비교가 가능합니다. 메서드를 호출하는 객체가 인자로 넘어온 객체보다 작을 경우에는 음수를 리턴하고, 크기가 동일하다면 0, 클 경우에는 양수를 리턴해야합니다.

게이머 랭키 페이지의 경우 높은 점수 순으로 내림 차순 정렬을 원하기 때문에, 인자로 넘어온 게이머의 점수에서 메서드를 호출하는 게이머의 점수를 빼면 됩니다. 예를 들어 인자로 넘어온 게이머의 점수가 982이고 compareTo() 메서드를 호출하는 객체의 점수가 1018이라면, compareTo() 메서드는 음수(982-1018)를 리턴하게 되며, 이는 곧 메서드를 호출하는 게미머가 인자로 넘어온 게이머보다 작다는 것을 의미합니다. 다시 말해, 메서드를 호출를 호출하는 메서드가 점수가 더 크지만, 객체 자체 비교에서는 인자로 넘어온 게이머보다 작은 객체가 됩니다.

Collections.sort(players);
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

이제 Collections.sort() 메서드에는 Comparable 인터페이스를 구현한 Comparable 타입의 Player 객체의 리스트가 인자로 넘어가기 때문에 더 이상 컴파일 에러가 발생하지 않습니다. 정렬 후 게이머 리스트를 출력해보면 원하는 바와 같이 점수가 제일 높은 Chloe 가 리스트의 맨 앞으로 위치하고, 점수가 제일 낮은 Alice 가 리스트의 맨 뒤에 위치하게 됩니다.

Comparator 객체 사용

만약 정렬 대상 클래스의 코드를 직접 수정할 수 없는 경우에는 어떻게 객체의 정렬 기준을 정의할 수 있을까요? 또는 정렬 하고자 하는 객체에 이미 존재하고 있는 정렬 기준과 다른 정렬 기준으로 정렬을 하고 싶을 때는 어떻게 해야할까요?

이 때 필요한 것이 바로 Comparable 인터페이스와 이름이 유사한 Comparator 인터페이스입니다. Comparator 인터페이스의 구현체를 Arrays.sort()나 Collections.sort()와 같은 정렬 메서드의 추가 인자로 넘기면 정렬 기준을 누락된 클래스의 객체나 기존 정렬 기준을 무시하고 새로운 정렬 기준으로 객체를 정렬할 수 있습니다.

Comparator<Player> comparator = new Comparator<Player>() {
    @Override
    public int compare(Player a, Player b) {
        return b.getScore() - a.getScore();
    }
};

Collections.sort(players, comparator);
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

위 코드는 Comparator 객체를 Collections.sort() 메서드의 두번째 인자로 넘겨서 이전 섹션과 동일한 정렬 결과를 만들어 내고 있습니다. 이렇게 Comparator 객체를를 인자로 넘기면, 정렬 대상 객체가 Comparable 인터페이스를 구현 여부와 상관없이, 넘어온 Comparator 구현체의 compare() 메서드 기준으로 정렬을 수행합니다. compare() 메서드는 비교 대상 2 개의 객체를 인자를 차례로 인자로 받습니다. 첫번째 인자가 두번째 인자보다 작다면 음수, 같다면 0, 크다면 양수를 리턴하면 됩니다.

람다 함수로 대체

Comparator 객체는 메서드가 하나 뿐인 함수형 인터페이스를 구현하기 때문에 람다 함수로 대체가 가능합니다.

Collections.sort(players, (a, b) -> b.getScore() - a.getScore());
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

Stream 으로 정렬

Stream 클래스의 sorted() 메서드도 Comparator 객체를 인자로 받아 정렬을 해줍니다. 스트림을 사용하면 위에서 살펴본 배열과 리스트의 정렬과 달리 기존 객체의 순서를 변경하지 않고, 새롭게 정렬된 객체를 생성하고자 할 때 사용됩니다.

List<Player> sortedPlayers = players.stream()
        .sorted((a, b) -> b.getScore() - a.getScore())
        .collect(Collectors.toList());
System.out.println(sortedPlayers); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

ref : https://www.javastudypoint.com/2019/03/comparable-vs-comparator-in-java.html

ref : https://www.daleseo.com/java-comparable-comparator/

ref :https://server-engineer.tistory.com/808

JAVA에서 기본적인 자료 구조를 제공하기 위한 환경을 JAVA Collection Framework라고 한다.

다음은 JAVA Collection Framework의 상속 기본 구조이다.

1.  Collection 인터페이스를 상속받아 List와 Set 인터페이스가 된다. List는 순서가 있는 Collection, 그리고 List는 Data 중복을 허락한다. 하지만 Set은 순서의 의미가 없으며 Data를 중복해서 포함할 수 없다.
2. Collection

• List 인터페이스의 특징
  • 순서가 있는 Collection.(이 순서는 삽입된 순서를 의미한다.)
  • Data를 중복해서 포함할 수 있다.
  • Stack의 특징
    • Data의 삽입과 추출이 후입선출(Last-In First-Out) 구조로 되어 있다.
    • push() method : Data 삽입할 때 사용
    • pop() method : Data 추출할 때 사용
    • peek() method : 추출할 Data를 삭제하지 않고 Data만을 가져 올 때 사용
    • search() method : Stack으로부터 Data를 검색할 때 사용
  • Vector의 특징
    • 자동으로 동기화를 보장해준다.
    • ArrayList에 동기화가 보장되도록 최적화한 클래스이다.
    • JAVA 5.0 이 후로는 AutoBoxing/AutoUnBoxing을 지원한다.
      • AutoBoxing이란? 기본 Data 타입을 Wrapper 클래스형의 객체로 자동으로 변환해주는 기능. AutoUnBoxing은 AutoBoxing의 반대 개념
      • JAVA 1.4까지

• JAVA 5.0이후

• addElement() method : Data를 삽입할 때 사용
• elementAt() method : Data를 추출할 때 사용, Index에 해당하는 객체를 얻어냄
• size() method : Vector 내에 존재하는 객체의 수를 얻어낼 대 사용
• insertElementAt() method : Vector 내에 중간 삽입할 때 사용
• setElementAt() method : Vector 내에 존재하는 Data를 수정할 때 사용
• indexOf() method : Vector 내에 Data를 검색할 때 사용, Index를 반환
• contains() method : Data의 존재 유무를 알기 위해 사용.

• ArrayList의 특징
  • 동기화를 보장해주지 않는다.
  • 배열에 동적 메모리 증가 기능을 구현한 클래스이다.
  • 동기화 지원 방법 : List list = Collections.synchronizeList(new ArrayList(…));
  • add() method : Data 삽입할 때 사용
  • get(0 method : Data 추출할 때 사용
  • toArray() method : ArrayList로부터 배열 얻어낼 때 사용
  • contains() method : Data의 존재 유무를 알기 위해 사용
  • size() method : ArrayList의 요소 개수를 얻어낼 때 사용

• Set 인터페이스의 특징
  • 집합적인 개념의 Collection
  • 순서의 의미가 없다.
  • Data를 중복해서 포함할 수 없다.
  • HashSet의 특징
    • add() method : Data 삽입할 때 사용
    • next() method : Data 추출할 때 사용
      • HashSet의 Data 추출은 Iterator을 이용하면 된다. Iterator는 Collection내의 모든 Data에 접근할 수 있는 특징이 있다. 그리고 Data의 마지막에 상관하지 않고 검색하기 위한 인터페이스이다. Set의 Iterator() method로 Iterator를 얻어 낼 수 있으며, Iterator의 hasNext() method를 이용해서 Data 끝을 만날 때까지 next() method를 호출해서 Data를 추출할 수 있다.

• remove() method : Data를 삭제할 때 사용
• contains() method : Data의 포함여부를 알기 위해 사용
• size() method : HashSet의 요소 개수를 얻어낼 때 사용
     

1. Map
   List와 Set이 순서나 집합적인 개념의 인터페이스라면 Map은 검색의 개념이 가미된 인터페이스이다. Map 인터페이스는 데이터를 삽입할 때 Key와 Value의 형태로 삽입되며, Key를 이용해서 Value를 얻을 수 있다.

• Hashtable, HashMap의 공통점
  • 내부적으로 모두 Hash 기법을 이용한다.
  • Map 인터페이스를 구현하고 있다.
  • Key와 Value를 이용해서 Data를 관리한다.
• Hashtable, HashMap의 차이점
  • Hashtable은 동기화가 보장된다.
  • HashMap은 동기화가 보장되지 않는다.
  • HashMap의 동기화 지원 방법 : Map m = Collections.synchronizedMap(New HashMap(…));
• Hashtable, HashMap과 HashSet과의 관계
  • Hashtable과 HashMap은 둘 다 Map 인터페이스를 구현하고 있다.
  • HashSet은 내부적으로 Hash기법을 사용하지만 Set인터페이스를 구현하고 있다.
• HashMap
  • 객체 생성 : Map<String, Integer> map = new HashMap<String, Integer>();
  • put() method : Data 삽입할 때 사용
  • get() method : Data를 추출할 때 사용, argument값은 Key를 사용
• Hashtable
  • 객체 생성 : Hashtable<String, Object> h = new Hashtable<String, Object>();
  • put() method : Data 삽입할 때 사용
  • get() method : Data를 추출할 때 사용, argument값은 Key를 사용

1. Sorted
   Set과 Map 인터페이스를 상속받아 정렬 기능이 추가된 SortedSet과 SortedMap 인터페이스가 된다. 그리고 이들은 각각 TreeSet 클래스와 TreeMap 클래스로 구성된다. TreeSet과 TreeMap은 Set과 Map의 기능을 가지고 있으면서 정렬 기능이 가미되었다는 것이 특징이다.

• Sorted를 지원하지 않는 클래스
  • HashSet, HashMap
• Sorted를 지원하는 클래스
  • TreeSet, TreeMap
• TreeMap
  • Key와 Value로 Data를 관리
  • Key를 기준으로 오름차순으로 정렬된다.
  • Map 인터페이스를 상속한 SortedMap 인터페이스를 구현한 클래스
• TreeSet
  • Set 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스
  • 데이터들이 자동으로 오름차순으로 정렬된다.
• Comparator
  • TreeSet과 TreeMap은 사용자가 직접 정렬의 방식을 지정할 수 있다.
  • TreeSet과 TreeMap은 정렬을 위한 Comparator 인터페이스를 구현하면 된다.
  • TreeSet에 Data를 집어 넣으면 기본적으로 오름차순(Ascending) 정렬이 되지만 그것도 문자열이나 기본 데이터 타입과 같은 단순한 것에만 해당된다. 이에 사용자가 직접 비교법을 넣어주기 위해 사용하는 것이 Comparator 인터페이스이다.
  • Comparator의 구현 방법 : Comparator 내부에 compare() method를 구현하면 된다.

• Comparator가 추가된 TreeSet의 생성

• Comparator가 추가된 TreeMap의 생성

• 일반적인 정렬기능의 사용
  • HashSet이나 HashMap을 정렬 기능이 지원되는 TreeSet이나 TreeMap으로 변환해서 사용
  • HashSet을 이용한 TreeSet 생성

• HashMap을 이용한 TreeMap 생성

ref : https://withwani.tistory.com/150

property

wrapper to specify read and write variable functionality using functions

template <typename Read, typename Write>
decltype(auto) property ( Read&& read_function, Write&& write_function );
template <typename Read>
decltype(auto) property ( Read&& read_function );
template <typename Write>
decltype(auto) property ( Write&& write_function );

These set of functions create a type which allows a setter and getter pair (or a single getter, or a single setter) to be used to create a variable that is either read-write, read-only, or write-only. When used during usertype construction, it will create a variable that uses the setter/getter member function specified.

#define SOL_ALL_SAFETIES_ON 1
#include <sol/sol.hpp>

#include "assert.hpp"

#include <iostream>

class Player {
public:
	int get_hp() const {
		return hp;
	}

	void set_hp( int value ) {
		hp = value;
	}

	int get_max_hp() const {
		return hp;
	}

	void set_max_hp( int value ) {
		maxhp = value;
	}

private:
	int hp = 50;
	int maxhp = 50;
};

int main (int, char*[]) {

	std::cout << "=== properties from C++ functions ===" << std::endl;

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.set("theplayer", Player());

	// Yes, you can register after you set a value and it will
	// connect up the usertype automatically
	lua.new_usertype<Player>( "Player",
		"hp", sol::property(&Player::get_hp, &Player::set_hp),
		"maxHp", sol::property(&Player::get_max_hp, &Player::set_max_hp)
	);

	const auto& code = R"(
	-- variable syntax, calls functions
	theplayer.hp = 20
	print('hp:', theplayer.hp)
	print('max hp:', theplayer.maxHp)
	)";

	lua.script(code);

	return 0;
}

ref : https://sol2.readthedocs.io/en/latest/api/property.html?highlight=sol%3A%3Aproperty#property

원문: http://tylerneylon.com/a/learn-lua/

ref : https://roboticist.tistory.com/576

hint 는 추가될 곳에 대한 힌트(위치)를 주는 것

template <class... Args> iterator emplace_hint (const_iterator position, Args&&... args);

Construct and insert element with hint

Inserts a new element in the map if its key is unique, with a hint on the insertion position. This new element is constructed in place using args as the arguments for the construction of a value_type (which is an object of a pair type).

The insertion only takes place if no other element in the container has a key equivalent to the one being emplaced (elements in a map container are unique).

If inserted, this effectively increases the container size by one.

The value in position is used as a hint on the insertion point. The element will nevertheless be inserted at its corresponding position following the order described by its internal comparison object, but this hint is used by the function to begin its search for the insertion point, speeding up the process considerably when the actual insertion point is either position or close to it.

The element is constructed in-place by calling allocator_traits::construct with args forwarded.

Parameters

positionHint for the position where the element can be inserted.
The function optimizes its insertion time if position points to the element that will follow the inserted element (or to the end, if it would be the last).
Notice that this does not force the new element to be in that position within the map container (the elements in a map always follow a specific order).
const_iterator is a member type, defined as a bidirectional iterator type that points to elements.args

• C++14
•  

Arguments forwarded to construct the new element (of type pair<const key_type, mapped_type>).
This can be one of:
- Two arguments: one for the key, the other for the mapped value.
- A single argument of a pair type with a value for the key as first member, and a value for the mapped value as second.
- piecewise_construct as first argument, and two additional arguments with tuples to be forwarded as arguments for the key value and for the mapped value respectivelly.
See pair::pair for more info.

Return value

If the function successfully inserts the element (because no equivalent element existed already in the map), the function returns an iterator to the newly inserted element.

Otherwise, it returns an iterator to the equivalent element within the container.

Member type iterator is a bidirectional iterator type that points to an element.

Complexity

Generally, logarithmic in the container size.
Amortized constant if the insertion point for the element is position.

www.cplusplus.com/reference/map/map/emplace_hint/

정적 캐스팅  static_cast  컴파일 타임에 잡아준다
 
 dynamic_cast 실행중에 잡아준다
 
 
static cast 의 경우 값 변환시 값을 유지할려고 한다(반올림 오차는 제외_, 이진수 표기는 달라질수 있음, ex 소수를 정수로 바구는 경우)
 
 컴파일 도중에 해준다 static cast 는 상속 관계만 따져서 상속관계에 있다면 컴파일 됨(실행중에는 문제가 생길수 있음)
 즉 완전 다른 상속관계의 캐스팅은 컴파일 에러를 벹는다
 실행도중 크래시 날수 있음
 변수형 체크 후 베이스 클래스를 파생 클래스로 변환시
 
 
 
 
 
 #include


class Animal
{
public:
Animal(){}

virtual void fn() {

}

private:

};

class Cat : public Animal
{
public:

private:

};

class Dog : public Animal
{
public:

private:

};

class AAA {

};


int main()
{

/*
정적 캐스팅
static_cast  컴파일 타임에 잡아준다

dynamic_cast 실행중에 잡아준다


static cast 의 경우 값 변환시 값을 유지할려고 한다(반올림 오차는 제외_, 이진수 표기는 달라질수 있음, ex 소수를 정수로 바구는 경우)

컴파일 도중에 해준다 static cast 는 상속 관계만 따져서 상속관계에 있다면 컴파일 됨(실행중에는 문제가 생길수 있음)
즉 완전 다른 상속관계의 캐스팅은 컴파일 에러를 벹는다
실행도중 크래시 날수 있음
변수형 체크 후 베이슼 ㅡㄹ래스를 파생 클래스로 변환시

*/


//static cast 로 값을 변할 할 경우 값을 유지하려고 한다 2진수 표기는 달라질 수 있음
int intVal = 30;
float fdd = static_cast(intVal); //컴파일 가능
char dd = static_cast(intVal); //컴파일 가능
//char* dd1 = static_cast<char*>(intVal); //컴파일 에러

Animal* animalCat = new Cat;
Cat* myCat = static_cast<Cat*>(animalCat);

Dog* ps = static_cast<Dog*>(animalCat); //static 은 상속관계만 따지기 때문에 에러가 안난다 animalCat 은 Animal 클래스를 부모로 두고 있는데 Dog 는 Animal 을 상속 받음으로, 그러나 위험함

//AAA* aaa = static_cast<AAA*>(animalCat); //상속관계가 없다면 컴파일 에러

//Dog* psd = dynamic_cast<Dog*>(animalCat); //이때는 컴파일 에러를 벹음

Dog* psd = dynamic_cast<Dog*>(animalCat); //!!!virtual 키워드가 없다면 이때는 컴파일 에러를 벹음
//, virtual 키워드가 있다면 컴파일 성공함, 그리고 null을 반환한다 
//dynamic cast 는 RTTI 가 켜 있어야 작동하는데 이것이 꺼져 있다면 static_cast 와 동일하게 동작한다



int b= 10;
int c = static_cast(b);
//unsigned int* c2 = static_cast(&b); //컴파일 에러
//unsigned int* c2 = reinterpret_cast(&b); //컴파일 가능
//int a = reinterpret_cast(b); //컴파일 에러
//Cat* catP = reinterpret_cast<Cat*>(&b); //컴파일 가능


/*
const_cast 는 (포인터의 상수성)만을 변경하고자 할때 사용한다!!!
값에는 안쓰이는데 값은 어차피 복사 되는거니깐 안전함
변수를 선언할 때 앞에 volatile을 붙이면 컴파일러는 해당 변수를 최적화에서 제외하여 항상 메모리에 접근하도록 만듭니다.

const_cast  로는 형을 바꿀 수는 없고 const 또는 volatile 애트리뷰트를 제거할때 사용한다
*/


//int iii = 30;
//const int ddd= const_cast(iii); //컴파일 에러

const int iii2 = 30;
//int ddd = const_cast(iii2); //컴파일 에러, 포인터가 아님
int* ddd = const_cast<int*>(&iii2); //컴파일 가능
const int* ddd3 = const_cast(&iii2); //컴파일 가능

int* tly = nullptr;
const int* ddd7 = const_cast(ddd); //컴파일 성공 const 를 붙여준다

//Animal* animalCat = new Cat;
//const Cat* myCat2 = static_cast(animalCat); //컴파일 가능
//const Cat* myCat2 = const_cast(animalCat); //const cast 는 형변환을 허용하지 않는다


return 0;
}

If the type T is a reference type, provides the member typedef type which is the type referred to by T. Otherwise type is T.

Member types

Helper types

Possible implementation

Example

true

false

false

true

true

true

ref : https://en.cppreference.com/w/cpp/types/remove_reference

IComparer<T> 제네릭 인터페이스의 구현에 대한 기본 클래스를 제공합니다.

[Serializable] public abstract class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer

예제

다음 예제에서는 파생 클래스 BoxLengthFirst는 Comparer<T> 로부터 상속 받은 클래스입니다. 

이 comparer 는 타입 Box 의 두 오브젝트를 비교합니다

먼저 길이에 의해 그다음, 높이, 너비에 의해 정렬됩니다. 

Box 클래스는 두 Box 오브젝트들 사이에서 기본 비교를 다루기위해  IComparable<T> 인터페이스를 구현합니다

이 기본 구현은 높이, 길이 그리고 넓이에 의해 정렬됩니다

예제는 차이점을 나타냅니다, 두 비교에서 이 비교는 Box오브젝트 List를 정렬하는 것 

첫번째로 BoxLengthFirst Comparer 를 사용하는 것 그리고 기본 comparer 를 사용하여 비교하는 것입니다

icOMPARER<t> 인터페이스를 상속 받아 구현한 클래스 입니다, 그와 같은 GENERIC 클래스들은 다음과 같은 것들이 있습니다

SortedList<TKey,TValue> and SortedDictionary<TKey,TValue> generic classes.

Remarks

Derive from this class to provide a custom implementation of the IComparer<T> interface for use with collection classes such as the SortedList<TKey,TValue> and SortedDictionary<TKey,TValue> generic classes.

The difference between deriving from the Comparer<T> class and implementing the System.IComparable interface is as follows:

• To specify how two objects should be compared by default, implement the System.IComparable interface in your class. This ensures that sort operations will use the default comparison code that you provided.

• To define a comparer to use instead of the default comparer, derive from the Comparer<T> class. You can then use this comparer in sort operations that take a comparer as a parameter.

The object returned by the Default property uses the System.IComparable<T> generic interface (IComparable<T> in C#, IComparable(Of T) in Visual Basic) to compare two objects. If type T does not implement the System.IComparable<T> generic interface, the Default property returns a Comparer<T> that uses the System.IComparable interface.

ref : https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.comparer-1?view=netframework-4.7.2

변환 할경우 변수를 toNum 처럼 만들어야 하는데 이를 좀 더 간결하게

out var 로 대체가 가능하다 C# 7.0 부터..

out 인수를 사용하여 메서드 호출

C# 6 및 이전 버전에서는 out 인수로 전달하기 전에 별도 문에서 변수를 선언해야 합니다. 

다음 예제에서는 Int32.TryParse 메서드에 전달되기 전에 number라는 변수를 선언합니다. 

이 메서드는 문자열을 숫자로 변환하려고 합니다.

string numberAsString = "1640"; int number; if (Int32.TryParse(numberAsString, out number)) Console.WriteLine($"Converted '{numberAsString}' to {number}"); else Console.WriteLine($"Unable to convert '{numberAsString}'"); // The example displays the following output: // 결과 : Converted '1640' to 1640

C# 7.0부터 별도 변수 선언이 아니라 메서드 호출의 인수 목록에서 out 변수를 선언할 수 있습니다. 

이렇게 하면 보다 간결하고 읽기 쉬운 코드가 생성되며 메서드 호출 전에 실수로 
변수에 값이 할당되는 경우를 방지할 수 있습니다. 

다음 예제는 Int32.TryParse 메서드 호출에서 number 변수를 정의한다는 점을 제외하고 이전 예제와 비슷합니다.

string numberAsString = "1640"; if (Int32.TryParse(numberAsString, out int number)) Console.WriteLine($"Converted '{numberAsString}' to {number}"); else Console.WriteLine($"Unable to convert '{numberAsString}'"); // The example displays the following output: // 결과 : Converted '1640' to 1640

앞의 예제에서 number 변수는 int로 강력하게 형식화됩니다. 

다음 예제와 같이 암시적 형식 지역 변수를 선언할 수도 있습니다.

string numberAsString = "1640"; if (Int32.TryParse(numberAsString, out var number)) Console.WriteLine($"Converted '{numberAsString}' to {number}"); else Console.WriteLine($"Unable to convert '{numberAsString}'"); // The example displays the following output: // 결과 Converted '1640' to 1640

ref : https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/out-parameter-modifier

런타임에서 타입 변환이 가능한 Dynamic 형식

dynamic 형식 사용

C# 4에서는 새로운 형식 dynamic을 소개합니다. 이 형식은 정적 형식이지만 dynamic 형식의 개체가 정적 형식 검사를 건너뜁니다.대부분의 경우 이 형식은 object 형식을 가지고 있는 것처럼 작동합니다. 컴파일 시간에 dynamic 형식의 요소는 모든 연산을 지원하는 것으로 간주됩니다. 따라서 개체가 값을 COM API, IronPython 같은 동적 언어, HTML DOM(문서 개체 모델), 리플렉션 또는 프로그램의 다른 곳 등 어디서 가져오든 신경을 쓸 필요가 없습니다. 그러나 코드가 유효하지 않으면 런타임 시 오류가 catch됩니다.

예를 들어 다음 코드의 인스턴스 메서드 exampleMethod1에 매개 변수가 하나뿐인 경우, 컴파일러는 메서드 ec.exampleMethod1(10, 4)에 대한 첫 번째 호출이 유효하지 않음을 인식합니다. 여기에 인수가 두 개 포함되었기 때문입니다. 호출 시 컴파일러 오류가 발생합니다. 컴파일러는 메서드 dynamic_ec.exampleMethod1(10, 4)에 대한 두 번째 호출을 확인하지 않습니다. dynamic_ec의 형식이 dynamic이기 때문입니다. 따라서 컴파일러 오류가 보고되지 않습니다. 그러나 이 오류는 알림을 무기한 이스케이프하지 않고, 런타임에 catch되며 런타임 예외를 일으킵니다.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following call to exampleMethod1 causes a compiler error 
    // if exampleMethod1 has only one parameter. Uncomment the line
    // to see the error.
    //ec.exampleMethod1(10, 4);

    dynamic dynamic_ec = new ExampleClass();
    // The following line is not identified as an error by the
    // compiler, but it causes a run-time exception.
    dynamic_ec.exampleMethod1(10, 4);

    // The following calls also do not cause compiler errors, whether 
    // appropriate methods exist or not.
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();}

class ExampleClass
{
    public ExampleClass() { }
    public ExampleClass(int v) { }

    public void exampleMethod1(int i) { }

    public void exampleMethod2(string str) { }
}

이 예제에서 컴파일러의 역할은 dynamic으로 형식이 지정된 개체 또는 식에 대해 각 문이 해야 할 일에 대한 정보를 패키지하는 것입니다. 런타임에는 저장된 정보의 검사가 수행되며, 유효하지 않은 문에서 런타임 예외가 발생합니다.

대부분의 동적 작업은 결과 그 자체가 dynamic입니다. 다음 예제에서 testSum이 사용된 곳에 마우스 포인터를 올려두면 IntelliSense에서 (지역 변수) dynamic testSum 형식을 표시합니다.

dynamic d = 1;
var testSum = d + 3;
// Rest the mouse pointer over testSum in the following statement.
System.Console.WriteLine(testSum);

결과가 dynamic이 아닌 작업은 다음을 포함합니다.

• dynamic에서 다른 형식으로의 전환.
• dynamic 형식의 인수를 포함하는 생성자 호출.

예를 들어 다음 선언에서 testInstance의 형식은 dynamic이 아니라 ExampleClass입니다.

var testInstance = new ExampleClass(d);

변환 예제는 다음 섹션인 "변환"에 나와 있습니다.

변환

동적 개체와 다른 형식 간에 손쉽게 변환할 수 있습니다. 따라서 개발자는 동적 동작과 비동적 동작 간에 전환할 수 있습니다.

다음 예제와 같이 개체를 동적 형식으로 암시적으로 변환할 수 있습니다.

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

반대로, 암시적 변환을 dynamic 형식의 식에 동적으로 적용할 수 있습니다.

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

동적 형식의 인수로 오버로드 확인

메서드 호출 내 하나 이상의 인수에 dynamic 형식이 있거나 메서드 호출의 수신자가 dynamic 형식인 경우 오버로드 확인은 컴파일 시간이 아니라 런타임에 발생합니다. 다음 예제에서 액세스 가능한 유일한 exampleMethod2 메서드가 문자열 인수를 사용하도록 정의되는 경우, d1을 인수로서 전송하면 컴파일러 오류는 발생하지 않지만 런타임 예외가 발생합니다. d1의 런타임 형식은 int인데 exampleMethod2에는 문자열이 필요하므로 오버로드 확인이 런타임에 실패합니다.

// Valid.
ec.exampleMethod2("a string");

// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);

동적 언어 런타임

DLR(동적 언어 런타임)은 .NET Framework 4의 새로운 API입니다. DLR은 C#에서 dynamic 형식을 지원하는 인프라를 제공하며, IronPython 및 IronRuby와 같은 동적 프로그래밍 언어를 구현합니다. DLR에 대한 자세한 내용은 동적 언어 런타임 개요를 참조하세요.

COM Interop

C# 4에는 Office 자동화 API와 같은 COM API와의 상호 운용 환경을 개선하는 몇 가지 기능이 포함되어 있습니다. 개선 사항 중에는 dynamic 형식의 사용 및 명명된 인수 및 선택적 인수의 사용이 포함됩니다.

많은 COM 메서드는 형식을 object로 지정하여 인수 형식 및 반환 형식의 변환을 허용합니다. C#에서는 강력한 형식의 변수로 조정하기 위해 값을 명시적으로 캐스팅해야 했습니다. /link(C# 컴파일러 옵션) 옵션을 사용하여 컴파일하는 경우 dynamic 형식을 사용하면 COM 서명에서 object의 발생을 마치 dynamic 형식인 것처럼 취급하여 캐스팅을 상당 부분 피할 수 있습니다. 예를 들어 다음 문은 dynamic 형식은 있고 dynamic 형식은 없는 Microsoft Office Excel 스프레드시트의 셀에 액세스하는 방법과 대조됩니다.

// Before the introduction of dynamic.
((Excel.Range)excelApp.Cells[1, 1]).Value2 = "Name";
Excel.Range range2008 = (Excel.Range)excelApp.Cells[1, 1];

// After the introduction of dynamic, the access to the Value property and
// the conversion to Excel.Range are handled by the run-time COM binder.
excelApp.Cells[1, 1].Value = "Name";
Excel.Range range2010 = excelApp.Cells[1, 1];

ref : https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/types/using-type-dynamic

결과 

1

9

25

49

81

1 9 25

True

33333

3 5

arr

1 4 9 16 25 36 49 64 81 100

arr2

3 5 3 5 3

[ 1 : 3 ],  [ 4 : 5 ],  [ 9 : 3 ],  [ 16 : 5 ],  [ 25 : 3 ],

익명 함수

익명 함수는 대리자 형식이 예상되는 곳에서 항상 사용할 수 있는 “인라인” 문 또는 식입니다. 

이를 사용하여 명명된 대리자를 초기화하거나 명명된 대리자 형식 대신 이를 메서드 매개 변수로 전달할 수 있습니다.

익명 함수에는 두 가지가 있고 각각 다음 항목에서 설명합니다.

C#에서 대리자의 발전

C# 1.0에서는 코드의 다른 위치에 정의된 메서드를 사용하여 명시적으로 초기화하는 방식으로 대리자의 인스턴스를 만들었습니다. 

C# 2.0에서는 대리자 호출에서 실행될 수 있는 이름 없는 인라인 문 블록을 작성하는 방법으로 무명 메서드의 개념을 소개했습니다. 

C# 3.0에서는 개념적으로 무명 메서드와 비슷하지만 더 간결하고 표현이 다양한 람다 식을 소개했습니다. 

이러한 두 기능을 함께 익명 함수라고 합니다. 

일반적으로 .NET Framework의 버전 3.5 이상을 대상으로 하는 응용 프로그램은 람다 식을 사용해야 합니다.

다음 예제에서는 C# 1.0에서 C# 3.0까지 대리자 만들기의 발전을 보여 줍니다.

ref : https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/statements-expressions-operators/anonymous-functions

컴파일 타임에 확장 메서드 바인딩

확장 메서드를 사용하여 클래스 또는 인터페이스를 확장할 수 있지만 재정의할 수는 없습니다. 
(확장 메소드 자체가 static 으로 정의됨)

이름과 시그니처가 인터페이스 또는 클래스 메서드와 동일한 확장 메서드는 호출되지 않습니다. 

컴파일 시간에 확장 메서드는 항상 형식 자체에서 정의된 인스턴스 메서드보다 우선 순위가 낮습니다. 

즉, 형식에 Process(int i)라는 메서드가 있고 동일한 시그니처를 가진 확장 메서드가 있는 경우 컴파일러는 항상 인스턴스 메서드에 바인딩합니다. 컴파일러는 메서드 호출을 발견할 경우 먼저 형식의 인스턴스 메서드에서 일치 항목을 찾습니다. 일치 항목이 없으면 형식에 대해 정의된 확장 메서드를 검색하고 찾은 첫 번째 확장 메서드에 바인딩합니다. 다음 예제에서는 컴파일러가 바인딩할 확장명 메서드 또는 인스턴스 메서드를 확인하는 방법을 보여 줍니다.

예

다음 예제에서는 C# 컴파일러가 메서드 호출을 형식의 인스턴스 메서드 또는 확장명 메서드에 바인딩할 것인지 결정할 때 따르는 규칙을 보여 줍니다. 정적 클래스 Extensions는 IMyInterface를 구현하는 모든 형식에 대해 정의된 확장 메서드를 포함합니다. A, B및 C 클래스는 모두 인터페이스를 구현합니다.

MethodB 확장 메서드는 이름과 시그니처가 클래스에서 이미 구현된 메서드와 정확하게 일치하므로 호출되지 않습니다.

일치하는 시그니처를 가진 인스턴스 메서드를 찾을 수 없으면 컴파일러는 일치하는 확장명 메서드(있는 경우)에 바인딩합니다.

결과

Extension.MethodA(this IMyInterface myInterface, int i)

Extension.MethodA(this IMyInterface myInterface, string s)

A.MethodB()

B.MethodA(int i)

B.MethodB()

Extension.MethodA(this IMyInterface myInterface, string s)

C.MethodA(object obj)

C.MethodA(object obj)

C.MethodB()

일반 지침

일반적으로 반드시 필요한 경우에만 드물게 확장 메서드를 구현하는 것이 좋습니다. 

가능하면 기존 형식을 확장해야 하는 클라이언트 코드는 기존 형식에서 파생된 새 형식을 만들어 이 작업을 수행해야 합니다. 
자세한 내용은 상속을 참조하세요.

기존 메서드를 사용하여 소스 코드를 변경할 수 없는 형식을 확장하는 경우 형식의 구현이 변경되어 확장명 메서드가 손상될 수도 있습니다.

지정된 형식에 대해 확장 메서드를 구현하는 경우 다음 사항에 유의하세요.

• 시그니처가 형식에 정의된 메서드와 동일한 확장 메서드는 호출되지 않습니다.

• 확장 메서드는 네임스페이스 수준에서 범위로 가져옵니다. 
  예를 들어 Extensions라는 단일 네임스페이스에 확장 메서드를 포함하는 여러 개의 정적 클래스가 있는 경우 using Extensions; 지시문을 통해 모두 범위로 가져옵니다.

구현된 클래스 라이브러리의 경우 어셈블리의 버전 번호가 증가되는 것을 방지하기 위해 확장 메서드를 사용해서는 안 됩니다. 소스 코드를 소유하고 있는 라이브러리에 중요 기능을 추가하려는 경우 어셈블리 버전 관리를 위한 표준 .NET Framework 지침을 따라야 합니다. 자세한 내용은 어셈블리 버전 관리를 참조하세요.

ref : https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/classes-and-structs/extension-methods

확장명 메서드를 사용하면 새 파생 형식을 만들거나 다시 컴파일하거나 원래 형식을 수정하지 않고도 기존 형식에 메서드를 "추가"할 수 있습니다. 확장 메서드는 특수한 종류의 정적 메서드이지만 확장 형식의 인스턴스 메서드인 것처럼 호출됩니다. C#, F# 및 Visual Basic에서 작성된 클라이언트 코드의 경우 확장명 메서드를 호출하는 것과 형식에 실제로 정의된 메서드를 호출하는 데는 명백한 차이가 없습니다.

다음 예제에서는 정수 배열에서 표준 쿼리 연산자 OrderBy를 호출하는 방법을 보여 줍니다. 괄호 안의 식은 람다 식입니다. 많은 표준 쿼리 연산자가 람다 식을 매개 변수로 사용하지만 확장명 메서드에 대한 요구 사항은 아닙니다. 자세한 내용은 람다 식을 참조하세요.

가장 일반적인 확장명 메서드는 쿼리 기능을 기존 System.Collections.IEnumerable 및 

System.Collections.Generic.IEnumerable<T>  형식에 추가하는 LINQ 표준 쿼리 연산자입니다.

표준 쿼리 연산자를 사용하려면 using System.Linq 지시문을 사용해서 먼저 범위를 지정합니다. 

그러면 IEnumerable<T>을 구현하는 모든 형식에 GroupBy, OrderBy, Average 등의 인스턴스 메서드가 있는 것처럼 나타납니다. 

List<T> 또는 Array와 같은 IEnumerable<T> 형식의 인스턴스 뒤에 "dot"를 입력하면 IntelliSense 문 완성에서 

이러한 추가 메서드를 볼 수 있습니다.

//상단에 아래 구문 필요

using System.Linq;

class ExtensionMethods2 { static void Main() { int[] ints = { 10, 45, 15, 39, 21, 26 }; var result = ints.OrderBy(g => g); foreach (var i in result) { System.Console.Write(i + " "); } } } //Output: 10 15 21 26 39 45

확장명 메서드는 정적 메서드로 정의되지만 인스턴스 메서드 구문을 사용하여 호출됩니다. 확장 메서드의 첫 번째 매개 변수는 메서드가 작동하는 형식을 지정하며 매개 변수 앞에 this 한정자가 있습니다. 확장 메서드는 using 지시문을 사용하여 명시적으로 네임스페이스를 소스 코드로 가져오는 경우에만 범위에 있습니다.

다음 예제에서는 System.String 클래스에 대해 정의된 확장 메서드를 보여 줍니다. 이 확장 메서드는 제네릭이 아닌 비중첩 정적 클래스 내부에서 정의됩니다.

namespace ExtensionMethods { public static class MyExtensions { public static int WordCount(this String str) { return str.Split(new char[] { ' ', '.', '?' }, StringSplitOptions.RemoveEmptyEntries).Length; } } }

WordCount 지시문을 사용하여 using 확장 메서드를 범위로 가져올 수 있습니다.

using ExtensionMethods;

또한 다음 구문을 사용하여 응용 프로그램에서 확장 메서드를 호출할 수 있습니다.

string s = "Hello Extension Methods"; int i = s.WordCount();

코드에서 인스턴스 메서드 구문을 사용하여 확장 메서드를 호출합니다. 그러나 컴파일러에서 생성된 IL(중간 언어)이 코드를 정적 메서드 호출로 변환합니다. 따라서 실제로 캡슐화의 원칙을 위반하지 않습니다. 사실상 확장명 메서드는 확장하는 형식의 private 변수에 액세스할 수 없습니다.

자세한 내용은 방법: 사용자 지정 확장 메서드 구현 및 호출을 참조하세요.

일반적으로 확장명 메서드를 직접 구현하는 것보다 호출하는 경우가 훨씬 많습니다. 확장 메서드는 인스턴스 메서드 구문을 사용하여 호출되므로 특별한 지식이 없어도 클라이언트 코드에서 확장 메서드를 사용할 수 있습니다. 특정 형식의 확장 메서드를 사용하려면 해당 메서드가 정의된 네임스페이스에 대해 using 지시문을 추가합니다. 예를 들어 표준 쿼리 연산자를 사용하려면 다음 using 지시문을 코드에 추가합니다.

using System.Linq;

System.Core.dll에 대한 참조를 추가해야 할 수도 있습니다. 이제 표준 쿼리 연산자가 대부분의 IEnumerable<T> 형식에 사용할 수 있는 추가 메서드로 IntelliSense에 표시됩니다.

아래 코드는  null 병합 연산자 ?? 와 혼용한 형태인데

?? 연산자의 경우 ?? 앞의 값이 null 이면 ?? 의 뒤에 값을 리턴하고

?? 앞에 있는 값이 null 이 아니면 앞의 값을 그대로 사용합니다

형식 매개 변수에 대한 제약 조건

제약 조건은 형식 인수에서 갖추고 있어야 하는 기능을 컴파일러에 알립니다. 제약 조건이 없으면 형식 인수가 어떤 형식이든 될 수 있습니다. 컴파일러는 모든 .NET 형식의 궁극적인 기본 클래스인 Object의 멤버만 가정할 수 있습니다. 자세한 내용은 제약 조건을 사용하는 이유를 참조하세요. 클라이언트 코드에서 제약 조건에 의해 허용되지 않는 형식을 사용하여 클래스를 인스턴스화하려고 하면 컴파일 시간 오류가 발생합니다. 제약 조건은 where 상황별 키워드를 사용하여 지정됩니다. 다음 표에는 7가지 형식의 제약 조건이 나와 있습니다.