개인적인 개발팁 모음

https://youtu.be/KfY6DqWtcqs?list=PLxU-iZCqT52Cmj47aKB1T-SxI33YL7rYS

위의 영상에 나오는 코드 따라해봄

UI가 XML로 되어 있는 것 빼고는 아직까지 C#과 동일

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Wpf5
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {

        BackgroundWorker worker;

        int sum = 0;

        public MainWindow()
        {
            InitializeComponent();
        }

        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);

            //Progress Changed 이벤트 발생 여부
            //작업취소 가능 여부
            worker = new BackgroundWorker()
            {
                WorkerReportsProgress = true,
                WorkerSupportsCancellation = true,
            };

            worker.DoWork += Worker_DoWork;

            worker.ProgressChanged += Worker_ProgressChanged;

            worker.RunWorkerCompleted += Worker_RunWorkerCompleted;

            MessageBox.Show("초기화");
        }

        private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled) MessageBox.Show("작업 취소");
            else if (e.Error != null) MessageBox.Show("에러 발생..." + e.Error);
            else
            {
                lblSum.Content = ((int)e.Result).ToString();
                MessageBox.Show("작업완료");
            }
        }

        private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            progressBar.Value = e.ProgressPercentage;
        }

        private void Worker_DoWork(object sender, DoWorkEventArgs e)
        {
            int count = (int)e.Argument;

            for(int i=0; i<=count; ++i)
            {
                if (worker.CancellationPending)
                {
                    e.Cancel = true;
                    return;
                }
                else
                {
                    Thread.Sleep(1000);
                    Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                        (ThreadStart)delegate ()
                        {
                            if(i%2 == 0)
                            {
                                sum += i;
                                e.Result = sum;
                                lstNumber.Items.Add(i);
                            }
                        });

                    worker.ReportProgress(i);
                }
            }

        }

        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            if(worker.IsBusy == true)
            {
                MessageBox.Show("작업이 진행중입니다");
            }
            else
            {
                int num = 0;
                if (int.TryParse(txtNumber.Text, out num) == false)
                {
                    MessageBox.Show("숫자를 입력하세요");
                    return;
                }

                progressBar.Maximum = num;
                lstNumber.Items.Clear();
                worker.RunWorkerAsync(num);
            }
        }

        private void btnCancel_Click(object sender, RoutedEventArgs e)
        {
            worker.CancelAsync();
        }
    }
}

* 웹알못의 기록

* 예제 1

* 서버

mux.HandleFunc("/get-time", func(rw http.ResponseWriter, r *http.Request) {
    ctime := Response{
        CurrentTime: time.Now().Format(time.RFC3339),
    }
    byteArray, err := json.Marshal(ctime)
    if err != nil {
        fmt.Println(err)
    }
    rw.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    rw.Header().Set("Content-Type", "application/json; charset=UTF-8")
    rw.Header().Set("Access-Control-Allow-Origin", "*")
    rw.WriteHeader(http.StatusOK)
    rw.Write(byteArray)
})

* 클라이언트

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
	<button id="gt">get time1</button>
    <div id="res"></div>
    <script>
        document.getElementById("gt").onclick = async (e) => {
            var req = await fetch("http://localhost:3000/get-time").then(r => r.json())
            document.getElementById("res").innerHTML = req.CurrentTime
			//alert(req.CurrentTime)
        }
    </script>
</body>
</html>

* 창로드

* 버튼을 누르면

* 예제 2

* 서버

func testHandler(w http.ResponseWriter, r *http.Request) {
	html := `<!DOCTYPE html>
	<html>
	<head>Title</head>
	<body>
	<fieldset style="width:670px">
	<legend>param1</legend>
	<label for="param1_id"  style="width:80px ">parameter1</label>
	<input id="param1_id" name="param1_id" type="text" style="width:550px"
	value="parameter1_value"/>
	<br/>
	<label for="param2_id"  style="width:80px ">parameter2</label>
	<input id="param2_id" name="param2_id" type="text" style="width:550px"
	value="parameter2_value"/>
	<br/>
	<button id="btn_send">send</button>
	<script>
	document.getElementById("btn_send").onclick = async (e) => {
		var obj = new Object();
		obj.argument1 = param1_id.value;
		obj.argument2 = param2_id.value;
		
		//alert(JSON.stringify(obj));
		
		var req = await fetch("test_send_func", {
			method: 'post',
			headers: {	'Content-Type': 'application/json;charset=utf-8', },
			body: JSON.stringify(obj)
		}).then(r => r.json())
		.then(function(json){
			//alert(JSON.stringify(json));
			document.getElementById("res").innerHTML = JSON.stringify(json)
		})
		


	}

	</script>
	</fieldset>

	<div id="res"></div>
	
	</body>
	</html>
	`

	fmt.Fprint(w, html)
}

type TestRecvObj struct {
	Arg1 string `json:"argument1"`
	Arg2 string `json:"argument2"`
}

func testSendHandler(w http.ResponseWriter, r *http.Request) {
	sendObj := new(TestRecvObj)
	//Client가 보낸 User
	err := json.NewDecoder(r.Body).Decode(sendObj)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprint(w, err)
		return
	}

	w.Header().Add("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	data, _ := json.Marshal(sendObj)
	fmt.Fprint(w, string(data))
}

//서버 등록
func NewHandler() http.Handler {
	mux := mux.NewRouter()
	mux.HandleFunc("/test_send_func", testSendHandler)
	mux.HandleFunc("/test", testHandler)
	return mux

}

* 화면 접속

* parameter 값을 바꾸고 버튼을 누르면

* 윈도우에서 빌드 하고 Jetson TX2에서 실행하기위한 크로스컴파일 방법 기록

* hello.go

package main

import "fmt"

func main() {
	fmt.Print("Hello world")
}

* 기본적으로 빌드를 하면 윈도우용 실행화일이 생성된다(hello.exe)

* 빌드할 환경 변수를 설정

set GOOS=linux
set GOARCH=arm64

* 환경변수를 설정하고 나서 빌드하면 확장자 없는 hello 파일이 생성된다

* hello 파일을 WinSCP를 이용해서 파일을  Jetson TX2로 복사

* ssh로 접속

* 계속 업데이트 예정 : 버튼을 누르면 시작

* 의문사항

1) 단독으로 브라우저에서 실행할 때는 paddle이 마우스 따라 다녔는데, 블로그에서는 그게 안되네.

* 수정 사항

1) [소스코드] Ball 클래스 추가

참조)

https://developer.mozilla.org/ko/docs/Games/Tutorials/2D_Breakout_game_pure_JavaScript/Create_the_Canvas_and_draw_on_it

* slice 이것저것

package main

import "fmt"

func main() {
	//빈 동적 배열(slice) 생성
	var a []int
	fmt.Println("len(a) = ", len(a))
	fmt.Println("cap(a) = ", cap(a))

	/*
		길이 : 쓰고 있는 공간
		Capacity : 확보한 공간
	*/
	//길이 : 5, capacity : 5 동적 배열(slice) 생성
	b := []int{1, 2, 3, 4, 5}
	fmt.Println("len(b) = ", len(b))
	fmt.Println("cap(b) = ", cap(b))

	//길이 : 0, capacity : 8 동적 배열(slice) 생성
	c := make([]int, 0, 8)
	fmt.Println("len(c) = ", len(c))
	fmt.Println("cap(c) = ", cap(c))

	c = append(c, 1)
	fmt.Println("len(c) = ", len(c))
	fmt.Println("cap(c) = ", cap(c))

	//append시 capacity에 따라서 같은 slice가 반환될수도 있고
	//복사 생성후 만들어진 다른 slice가 반환될수도 있다

	d := []int{1, 2}
	e := append(d, 3)
	//주소번지를 출력
	fmt.Printf("d : %p, e : %p", d, e)
	fmt.Println()

	for i := 0; i < len(d); i++ {
		fmt.Printf("c[%d} : %d, ", i, d[i])
	}
	fmt.Println()
	fmt.Println("len(d) : ", len(d), ", cap(d) : ", cap(d))
	fmt.Println()

	for i := 0; i < len(e); i++ {
		fmt.Printf("e[%d] : %d, ", i, e[i])
	}
	fmt.Println()
	fmt.Println("len(e) : ", len(e), ", cap(e) : ", cap(e))
	fmt.Println()

	//append시 Capacity가 여유가 있어서 다른 메모리를 할당받지 않으면
	//같은 주소에 추가만 한다
	f := make([]int, 2, 4)
	g := append(f, 1)
	fmt.Printf("%p %p\n", f, g)

	f[0] = 1
	f[1] = 2
	fmt.Println(f)
	fmt.Println(g)

	g[0] = 4
	g[1] = 5
	fmt.Println(f)
	fmt.Println(g)
}

package main

import "fmt"

func main() {
	a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	//4번째 인덱스부터 6번째 인덱스 전까지
	fmt.Println("a[4:6] : ", a[4:6])
	//4번째 인덱스부터
	fmt.Println("a[4:] : ", a[4:])
	//처음부터 4번째 인덱스까지
	fmt.Println("a[:4] : ", a[:4])

	//b는 원 배열을 가르키는 포인터이므로
	//변경하게 되면 원 배열을 변경한다
	b := a[1:3]
	b[0] = 0
	b[1] = 1
	fmt.Println("a : ", a)

	//가장 뒷자리 숫자를 없애면서 그 숫자가 무엇인지 출력
	var Num int
	a, Num = RemoveBack(a)
	fmt.Println(a, Num)
	a, Num = RemoveBack(a)
	fmt.Println(a, Num)

	a, Num = RemoveFront(a)
	fmt.Println(Num, a)

	a, Num = RemoveFront(a)
	fmt.Println(Num, a)
}

func RemoveBack(a []int) ([]int, int) {
	return a[:len(a)-1], a[len(a)-1]
}

func RemoveFront(a []int) ([]int, int) {
	return a[1:len(a)], a[0]
}

* slice는 3개의 property로 구성된 구조체이다

  1) Pointer : 시작주소

  2) len : 갯수

  3) capacity : 최대갯수

package main

import "fmt"

func main() {

	var s []int

	s = make([]int, 3)

	s[0] = 100
	s[1] = 200
	s[2] = 300

	//초기 3개 생성시 갯수 3개, capcity : 3개
	fmt.Println(s, len(s), cap(s))

	s = append(s, 400, 500, 600, 700)

	//4개 추가시 갯수 7개, capcity : 8개
	fmt.Println(s, len(s), cap(s))
}

* 메모리를 공유하다 보니 문제가 발생하기도 한다

더보기

package main

import "fmt"

func main() {

	var s []int

	s = make([]int, 3, 8)

	s[0] = 100
	s[1] = 200
	s[2] = 300

	//초기 3개 생성시 갯수 3개, capcity : 3개
	fmt.Println(s, len(s), cap(s))

	t := append(s, 400)

	//4개 추가시 갯수 7개, capcity : 8개
	fmt.Println(s, len(s), cap(s))
	fmt.Println(t, len(t), cap(t))
	t = append(t, 500)

	fmt.Println(s, "S", len(s), cap(s))
	fmt.Println(t, "T", len(t), cap(t))

	s = append(s, 600)

	fmt.Println(s, "S", len(s), cap(s))
	fmt.Println(t, "T", len(t), cap(t))
}

유튜브 보고 따라 친건데, 다음과 같이 하면 브라우저에서 저 문구들을 볼 수 있다(포트번호는 3000번)

package main

import (
	"fmt"
	"net/http"
)

type fooHandler struct{}

func (f *fooHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello Foo!")
}

//핸들러 함수를 등록할 수 있다
func barHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello Bar!")
}
func main() {
	//어떤 경로의 요청이 들어왔을 때
	//어떤 일을 할 것인지
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		//fmt.Fprint : writer에 출력하라
		fmt.Fprint(w, "Hello World")
	})

	http.HandleFunc("/bar", barHandler)

	http.Handle("/foo", &fooHandler{})

	http.ListenAndServe(":3000", nil)
}

서버 포트를 열어야 하므로 다음과 같이 보안 관련 다이얼로그가 뜨긴 한다

* http객체 대신 mux를 이용하여 똑같은 기능(아직 왜 다른지는 모름)

package main

import (
	"fmt"
	"net/http"
)

type fooHandler struct{}

func (f *fooHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello Foo!")
}

func barHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello Bar!")
}
func main() {
	//어떤 경로의 요청이 들어왔을 때
	//어떤 일을 할 것인지
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		//fmt.Fprint : writer에 출력하라
		fmt.Fprint(w, "Hello World")
	})

	mux.HandleFunc("/bar", barHandler)

	mux.Handle("/foo", &fooHandler{})

	http.ListenAndServe(":3000", mux)
}

* http 클라이언트 request의 argument를 받아서 처리

func barHandler(w http.ResponseWriter, r *http.Request) {

	name := r.URL.Query().Get("name")
	if name == "" {
		name = "Empty"
	}

	fmt.Fprintf(w, "Hello %s!", name)
}

* UTF8 문자열 한글자씩 출력하기

    s := "Hello 월드"

	s2 := []rune(s)
	for i := 0; i < len(s2); i++ {
		fmt.Print(string(s2[i], ","))
	}

* 배열 역순으로 놓기

arr := [5]int{1, 2, 3, 4, 5}

	for i := 0; i < len(arr)/2; i++ {
		arr[i], arr[4-i] = arr[4-i], arr[i]
	}

	fmt.Println(arr)

* swap (a와 b를 바꾸기)

a := 1
	b := 2

	a, b = b, a

	fmt.Print("a : ", a, ", b : ", b)

* 구조체 선언 및 할당

package main

import "fmt"

//구조체 선언
type Person struct {
	name string
	age  int
}

//구조체 멤버 함수
func (p Person) PrintName() {
	fmt.Print(p.name)
}

func main() {
	//초기화
	var p Person
	p1 := Person{"Name1", 15}
	p2 := Person{name: "Name2", age: 11}
	p3 := Person{name: "Name3"}
	p4 := Person{}

	fmt.Println(p, p1, p2, p3, p4)

	//멤버 변수 할당
	p.name = "new Name"
	p.age = 100

	fmt.Println(p)

	//멤버 함수 실행
	p.PrintName()
}

* 포인터 타입으로 선언

var p* Person

p := *Person{"Name", 20}

* 구조체를 멤버로 가지는 구조체

  - 일반함수와 멤버함수의 호출방법

더보기

package main

import "fmt"

//구조체 선언
type Student struct {
	name  string
	class int

	sungjuk Sungjuk
}

type Sungjuk struct {
	name  string
	grade string
}

//멤버함수
func (s Student) ViewSungjuk() {
	fmt.Println(s.sungjuk)
}

//멤버함수 : 입력
func (s Student) InputSungjuk(name string, grade string) {
	s.sungjuk.name = name
	s.sungjuk.grade = grade
}

//일반함수
func ViewSungjuk(s Student) {
	fmt.Println(s.sungjuk)
}

func main() {
	var s Student
	s.name = "철수"
	s.class = 1

	s.sungjuk.name = "수학"
	s.sungjuk.grade = "C"

	//멤버함수 호출
	s.ViewSungjuk()
	//일반함수 호출
	ViewSungjuk(s)

	//아래와 깉이 입력해도 바뀌지 않는다
	s.InputSungjuk("과학", "A")
	s.ViewSungjuk()
}

 

* 그런데, golang에서 구조체의 멤버함수라 해도 Call by Value 방식으로 구조체 인스턴스를 복사하는 방식이라 그냥 대입해서는 값이 바뀌지 않는다

* 포인터 기본 사용법

더보기

func main() {
	var a int
	var b int
	var p *int

	p = &a
	a = 3
	b = 2

	fmt.Println("a : ", a)
	fmt.Println("p : ", p)
	fmt.Println("*p : ", *p)

	p = &b

	fmt.Println("a : ", b)
	fmt.Println("p : ", p)
	fmt.Println("*p : ", *p)

}

* 포인터의 성질

더보기

func main() {
	var a int
	var b int

	a = 1
	b = 1

	IncVal(a)
	IncPointer(&b)

	fmt.Println("a : ", a)
	fmt.Println("b : ", b)
}

func IncVal(x int) {
	x++
}

func IncPointer(x *int) {
	*x = *x + 1
}

* 가비지 콜렉터 또는 허상참조(dangling reference) : C/C++과 달리 참조 값이 0이 될때까지 메모리 해제가 안된다

더보기

package main

import "fmt"

func main() {
	var p *int
	p = f1()
	fmt.Printf("P : %d", *p)
}

func f1() *int {
	a := 3
	return &a
}

강좌 보면서 따라한 내용을 혹시나 해서 기록해본다

package main //이 패키지의 이름은 main이다
//main이라는 package는 '프로그램 시작점'이라는 약속


//아래의 package를 가져와서 포함한다
//fmt를 포함한 아래 목록은 표준 package
import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

//func : 함수
//main 함수는 시작점이다
func main() {
	fmt.Print("Input Number 1 : ")
	//표준 입력을 받기 위한 객체
	reader := bufio.NewReader(os.Stdin)

	//input string과 error를 리턴 받는데, error는 변수에 담지 않는다
	line, _ := reader.ReadString('\n')
    //공백 제거
	line = strings.TrimSpace(line)
    //정수 변환
	n1, _ := strconv.Atoi(line)

	fmt.Print("Input Number 2 : ")
	line, _ = reader.ReadString('\n')
	line = strings.TrimSpace(line)
	n2, _ := strconv.Atoi(line)

	fmt.Printf("Input Number : %d %d", n1, n2)

	fmt.Print("Input Operator : ")
	line, _ = reader.ReadString('\n')
	line = strings.TrimSpace(line)

	if line == "+" {
		fmt.Printf("%d + %d = %d", n1, n2, n1+n2)
	} else if line == "-" {
		fmt.Printf("%d - %d = %d", n1, n2, n1-n2)
	} else if line == "*" {
		fmt.Printf("%d * %d = %d", n1, n2, n1*n2)
	} else if line == "/" {
		fmt.Printf("%d / %d = %d", n1, n2, n1/n2)
	} else {
		fmt.Println("Bad Input!!!")
	}

	switch line {
	case "+":
		fmt.Printf("%d + %d = %d", n1, n2, n1+n2)
	case "-":
		fmt.Printf("%d - %d = %d", n1, n2, n1-n2)
	case "*":
		fmt.Printf("%d * %d = %d", n1, n2, n1*n2)
	case "/":
		fmt.Printf("%d / %d = %d", n1, n2, n1/n2)
	default:
		fmt.Println("Bad Input!!!")
	}

}

go는 case 문 안에 수식이 들어가도 되고,

switch에 공백이 있으면 true가 기본 값이다

package main

import "fmt"

func main() {
	x := 30

	switch {
	case x > 20:
		fmt.Println("X는 20보다 크다")
	case x < 20:
		fmt.Println("X는 20보다 작다")
	default:
		fmt.Println("Dfault")
	}
}

for 문은 다음과 같이 쓴다

package main

import "fmt"

func main() {

	i := 0
	for i < 10 {
		if i > 0 {
			fmt.Print(",")
		}
		fmt.Print(i)
		i++
	}
	fmt.Println()

	for j := 0; j < 10; j++ {
		if j > 0 {
			fmt.Print(",")
		}

		fmt.Print(j)
	}
	fmt.Println()
}

조건문에 공백이면 true이다(무한루프)

break, continue등도 사용가능

package main

import "fmt"

func main() {

	i := 0
	for {
		if i > 0 {
			fmt.Print(",")
		}
		fmt.Print(i)

		i++
		if i > 9 {
			break
		}
	}
	fmt.Println()

	for j := 0; j < 10; j++ {

		if j == 3 {
			continue
		}

		if j > 0 {
			fmt.Print(",")
		}

		fmt.Print(j)
	}
	fmt.Println()
}

* 함수

//함수명(변수 타입, ) 리턴값
//리턴은 복수개 가능
func add(x int, y int) int {
	return x + y
}

func main() {
	// for i := 0; i < 10; i++ {
	// 	fmt.Printf("%d + %d = %d\n", i, (i + 2), add(i, i+2))
	// }

	a, b := func1(2, 3)
	fmt.Println(a, b)

}

//같은 타입이면 마지막에 붙여도 됨
func func1(x, y int) (int, int) {
	func2(x, y)
	return y, x
}

func func2(x, y int) {
	fmt.Println("func2", x, y)
}

워낙 안드로이드 문외한이라 제목이 맞는지도 잘 모르겠음

아무튼 따라하기 하다가 아래처럼 외부 라이브러리를 추가하고(build.gradle) Sync(코끼리?)를 눌렀더니 문제 발생하고 

구글링 시작함..-_-

삽질에 삽질을 거듭한 결과 

* build.gradle

* setting.gradle

이렇게 하니깐 Sync가 됨

아직 원인은 모름... 문외한이라..-_-

1. 변수의 최대 최소값 구하기

#include <algorithm>


int val1 = -10;
int val2 = -5;
std::cout << std::min(val1, val2) << std::endl;

/*기본적으로 < 순서인데, 양쪽에 절대값이므로 절대값 기준의 최대 최소를 가져온다*/
std::cout << std::min(-10, -5, [](int a, int b) {
    return std::abs(a) < std::abs(b);
}) << std::endl;

auto pairInt = std::minmax(201, 202);
std::cout << "Min : " << pairInt.first << std::endl;
std::cout << "Max : " << pairInt.second << std::endl;

auto pairSeq = std::minmax({ 2,3,43,5,6,7 });
std::cout << "Min : " << pairSeq.first << std::endl;
std::cout << "Max : " << pairSeq.second << std::endl;

2. 배열에서 최대/최소값 구하기

#include <algorithm>

//std::begin, std::end를 이용
int arr[3] = { 1,2,3 };
auto res_min = std::min_element(arr, arr + 3);
auto res_max = std::max_element(arr, arr + 3);
auto res_min2 = std::min_element(std::begin(arr), std::end(arr));
auto res_max2 = std::max_element(std::begin(arr), std::end(arr));

3. vector의 이동

//1000000개의 vector, 각 항목은 1
std::vector<int> srcVec(1000000, 1);

//vector의 복사가 이루어진다
std::vector<int> dstVec  = srcVec;
//srcVec을 잘라내서 dstVec2에 붙여 넣는다
std::vector<int> dstVec2 = std::move(srcVec);

4. std::funcion, std::bind

    std::function<double(double, double)> mDiv1 = std::bind(diveMe, std::placeholders::_1, std::placeholders::_2);
    std::function<double(double)>         mDiv2 = std::bind(diveMe, 20000, std::placeholders::_1);

    double mDiv1_Result = mDiv1(1, 2);
    double mDiv2_Result = mDiv2(2);

    std::map<const char, std::function<double(double, double)>> tab;
    tab.insert(std::make_pair('+', [](double a, double b) {return a + b; }));
    tab.insert(std::make_pair('-', [](double a, double b) {return a - b; }));
    tab.insert(std::make_pair('*', [](double a, double b) {return a * b; }));
    tab.insert(std::make_pair('/', [](double a, double b) {return a / b; }));

    std::cout << " 3 + 5 : " << tab['+'](3, 5) << std::endl;
    std::cout << " 3 - 5 : " << tab['-'](3, 5) << std::endl;
    std::cout << " 3 * 5 : " << tab['*'](3, 5) << std::endl;
    std::cout << " 3 / 5 : " << tab['/'](3, 5) << std::endl;