하마
7k
2015-06-04 10:51:38
1
3821

함수포인터에서 람다까지 with Polyglot Code


함수포인터에서 람다까지 with Polyglot Code 



함수 포인터의 정의는  전달가능한 행위의 시작위치! 라고 말할수있으며 사용이유로는  
아래와 같이 3가지정도를 말할수있을듯 합니다.  1번이 가장 핵심이구요 .
람다도 마찬가지로 지연호출이 핵심 ( +  직관적인  표현식 ) 입니다.

지연호출의 예로는 

 * GUI 이벤트에 대한 리스너 

 * 실제 사용될때서야  로드되는 리소스 

 * 비동기 통신에서 Reader / Writer

 * Ajax 에서 success / error  함수  

 * 행사코드및 각종 준비사항들은 서드파티라이브러리한테 맡기고 비지니스 로직만 간편히 넘기는경우

 * Dynamic proxy 의 invoker 

 * Active Object & Actor 패턴 에서의 전달 메세지  

 * Command 패턴에서 execute

 * Future 패턴에서 real 

 * 하둡/하마 같은것들에서 잡 

 

같은것들이 있으며  C 포인터에서는 아래와 같은 장점을 갖게합니다.



1. 호출시점 유연화.
2.  struct 에서 행위를 포함할수있게함
3. 디펜던시 문제 해결.  


예제  in C ) 

#include <stdio.h>

void apple(void)
{
  printf("apple");
};


int main()
{
  void (*fptr)(void);          // 선언
  fptr = apple;                // 대입
  fptr();                      // 호출
  someFunction(fptr);          // 매개변수로 넘김.
}
 fptr 는 행위 (애플이라고 프린팅하는) 를  가르키고있습니다.  
행위를  함수의 매개변수로 넘겨서 다른곳(someFunction)에서 그 행위에 대한 책임을 지도록  합니다.

예제  in C++ ) 

#include <iostream>
using namespace std;
class fruit
{
	public:
		void apple()
		{
			cout << "apple" << endl;
		}
		void berry()
		{
			cout << "berry" << endl;
		}
};

int main()
{
	fruit x, *y;
	void (fruit::*f)(void);    //  선언 
	
	f = &fruit::apple;         //  대입
	(x.*f)();                  //  호출

	f = &fruit::berry;
        y = new fruit;
	(y->*f)();

	delete y;
} 

C 에는 없는 클래스라는 개념을 가지고있는 C++ 
클래스의 멤버함수를 가르키는 방법입니다. 객체를 가르키는 방법에 따라 다르기때문에  복잡합니다.
헤깔리기때문에 보통 사용할때 구글링으로 확인합니다.


예제 in C++ with boost) 

class CHello
{
	void Say()
	{ 
		print(“hello”); 
        }
};

Void func1()
{
	CHello hello;                                             // CHello 의 객체 선언 
	boost::function< void ( void ) > memfunc;                 // boost::function 객체 선언
	memfunc = boost::bind( &CHello::DebugOut, hello, _1 );    // DebugOut 함수를 func 에 바인딩

        func2(memfunc);     
}     
                                                                      
Void func2(boost::function< void ( void ) >   _func)
{

    _func( 5 );     // CHello::Say() 가 호출!!!  	1.  행위를 하게함. ( observer 패턴)  
                    //                          2.  호출위치를 조절할수도 있고 
                    //                          3.  다른모듈에서 CHello를 호출.(디펜던시문제)

} 

위에는 클래스에 대한 멤버함수를 포인팅하는 방법을 좀더 쉽게 하기위해서
비표준 라이브러리에서  function과 bind가 사용되었습니다.근데 진짜 저게 더 쉬워진걸까?
의문입니다. 
역시 쓸때마다 구글링합니다. 

예제 in C++ 11) 

#include <iostream>
#include <functional>

using namespace std;

int add(int a, int b) {
    return a + b;
}

int main() {
    auto f = bind(add, 1, 2);
    cout << f() << "\n";
}

///////////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <functional>

using namespace std;
using namespace std:placeholders;

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add1 = bind(add, 1, _1);
    cout << add1(100) << "\n";
}


자. c++11  에 와서 boost  라는 비표준라이브러리를 안쓰고 표준라이브러리를 사용하면서
조금 깔끔해졌습니다. auto의 등장 



예제  in C++  11 이전 ) 

boost::asio::ip::tcp::acceptor m_acceptor;
 
void handle_accept(Session* pSession, const boost::system::error_code& error)
{
  if (!error)
  {     
       std::cout << "클라이언트 접속 성공" << std::endl;
                   
       pSession->PostReceive();
  }
}
 
m_acceptor.async_accept( m_pSession->Socket(),
                         boost::bind(&TCP_Server::handle_accept,  // 함수 객체를 넘긴다. (함수포인터넘겨도됨)
                         this,
                         m_pSession,
                         boost::asio::placeholders::error)
                    );

예제 in C++ 11 이후) 


boost::asio::ip::tcp::acceptor m_acceptor;
 
 
m_acceptor.async_accept( m_pSession->Socket(),
                     [this](boost::system::error_code error)   // 람다식을 넘김!!
                    {
                       if (!error)
                       {  
                          std::cout << "클라이언트 접속 성공" << std::endl;
                          m_pSession->PostReceive();
                       }
                      
                       StartAccept();
                    }
                    );

C++도 11 버전 (2011년)  이전에는  함수자 or 서술자를 쓸때 그것들의 위치가 실제 사용되는 함수와 
거리가 멀어지는 문제점때문에 쓰기 꺼렸었지만, 11 버전 이후에 람다가 표준이 되면서 좀 더 많이 사용될것이라고 생각됩니다.


예제 in JAVA)    

Public void foo()
{
        final int n = 1;
	Class  ActionListener() 
	{
		Pubic void actionPerformed(Action e)
		{
			System.out.pringln(“Clicked! N =” +n);
		}
	}
      ActionListener ac = new ActionListener() 
      
      
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(ac);
}

자바 내부클래스입니다.
final int n = 1; 여기서 n 이 내부클래스에서 참조되는게 중요한데..
저게 바로 클로저라고 하죠. 내부에서 외부의 존재를 참조하는것!! 
다만 final 이 꼭 붙어야해서 클로저가 아니다라는 말도 합니다.


예제 in JAVA   익명클래스 

Public void foo()
{
	final int n = 1;
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(new ActionListener() 
				{
					Pubic void actionPerformed(Action e)
					{
						System.out.pringln(“Clicked! N =” +n);
					}
			});
}




ActionListener 클래스가 함수매개변수로 바로 만들어져 삽입된다.


예제 in JAVA 8 with lamda 


Public void foo()
{
      final int n = 1;
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(  ()-> System.out.pringln(“Clicked! N =” +n);
			      );
} 

자바는 함수를 따로 만드는게 언어철학차원에서 지원하지 않기때문에 C++보다 내부 구현에 복잡해질 여지가 많다고 합니다. 어설프게 타언어 장점 가져올바에는 일관성을 지키는게 훨씬 낫겠지요.


예제 in C# with delegate

          //대리자 선언
          public delegate void SayHandler(string mag);
                
            [1]익명메서드 : Say 함수를 작성하지 않고 익명메서드로 작성
            SayHandler hi = delegate(string msg)
            {
                Console.WriteLine(msg);
            };
            hi("익명메서드");

            //[2]익명메서드 : Button의 click event를 익명 메서드로 작성
            Button button = new Button();
            button.Click += delegate(string msg) 
            {
                Console.WriteLine(msg);
            };
            button.OnClick("이벤트 익명메서드");


            //[3]람다표현식 : Button의 click event를 Ramda 표현식으로 작성
            Button button1 = new Button();
            button1.Click += (string msg) => Console.WriteLine(msg);
 
            button.OnClick("람다 표현식");
           
            

 C# 도 1버전부터 4버전까지 계속 대리자(함수포인터 , 람다) 가 발전되어져 왔다.


예제 in Scala  with lamda

스칼라에서 함수표현 

def max(m: Int, n: Int): Int = if(m > n) m else n

스칼라에서의 람다식

1) 보통 

def bubbleSort(arr: Array[Int], order: (Int, Int) => Boolean): Unit {
    ...
    val o: Boolean = order(a, b)
    ...
}

val arr: Array[Int] = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (a: Int, b: Int) => a > b)

2) 짧게 
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (a, b) => a > b)


3) 더 짧게
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (_: Int) > (_: Int))

4) 가장 짧게
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, _ > _)


 예제  in Scala vs JAVA8   with lamda)


JAVA8  ) 
List names = Arrays.asList("1", "2", "3");
Stream lengths = names.stream().map(name -> name.length());

Scala ) 
val names = List("1", "2", "3")
val lengths = names.map(name => name.length)



JAVA8  )
List<Photo> photos = Arrays.asList(...)
List<Photo> output = photos.filter(p -> p.getSizeInKb() < 10)

Scala ) 
val photos = List(...)
val output = photos.filter(p => p.sizeKb < 10)


예제 in javascript)


function applyOperation(a, b, operation) 
{
  return operation(a,b);
}

function add(a,b) { return a+ b; }

applyOperation(1,2, add);


// anonymous inline function
applyOperation(4,7, function(a,b) {return a * b})


예제 in Ruby with lamda)

class Array
  def iterate!(code)
    self.each_with_index do |n, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate!(lambda { |n| n ** 2 })

puts array.inspect

# => [1, 4, 9, 16]


예제  in JAVA )   12보다 큰 단어의 워드카운팅.


int count = 0;
for(String w : words){
   if (w.length > 12 ) count++;
}
머하는지 일단 읽어봐야하고 혹시 index 증감으로 배열참조하다보면 오류생길가능성도 조금 더 있겠지만 
깔끔하고 너무나 익숙하다.  


예제  in JAVA 8 with lamda )  

long count = words.stream().filter( w -> w.length() > 12 ).count();
람다를 이용하여 한줄에 작성되었다. 이거 좋다고 이렇게 쓰자고 난리다. 
다양한 알고리즘도 미리 제공해주고 있다. 흠 근데 아직 잘 모르겠다. 복잡한거 같다.
아마 저거 쓸때마다 레퍼런스 참고해야할거고,,, 걍  foreach  로  로직만들자!!  패스~


예제 in JAVA  8 with lamda and parallel )

long count = words.parallelStream().filter ( w -> w.length() > 12).count()

어라, 병렬을 한방에 해주네??  이 정도면 끌리는데? 어려워도 배워볼만하네.
이게 추상화의 장점이구나!! 기능추가의 자유도가 쉽게 높아지는군! 나는 아무것도 고친게 없는데 
(버전업되면) 저절로 강해지네? 

만약 저걸 하둡의 맵 or 리듀스공정에 사용하면 손쉽게 분산병렬과 쓰레드레벨 병렬의 시너지가
날듯합니다.( 여기에 추가적으로 GPU레벨 믹스도 추상화가 높아지면 쉬워지겠네요. )

참고로 c++ 은 저렇게 언어 차원에서 저런식의 병렬을 지원하지 않으며 openMP 나 PPL 같은
외부 라이브러리를 통해  지원합니다.



 P.S 자바 8,9 의 parallelStream 에 대해서 깊이있는 이해는 없다는걸 말씀드립니다. 
   좋은 강좌가 올라왔으면 하는 바람입니다.

 P.S 전에 올렸던 글인데  포럼보다는 팁/테크에 있는게 나을거 같아서 옮겼습니다.


참고: 
폴리글랏 프로그래밍 (임백준) : http://www.yes24.com/24/Goods/12204890?Acode=101
3
  • 댓글 1

  • dkb
    2015-06-04 11:15:12
    좋은 글 감사합니다.
  • 로그인을 하시면 댓글을 등록할 수 있습니다.