TCP / IP Socket Programming

./hello_server 9190 ./hello_client 127.0.0.1 9190

---- 파일 디스크립터 설명

---- 포트 번호 < 오후 >

SAMBA 서버 구축

$ sudo apt-get install samba samba-common-bin

$ sudo smbpasswd -a pi // (pi) 유저의 패스워드 설정

$ vim /etc/samba/smb.conf // vim 에 아래 추가

[aaa] comment = pi share folder path = /home/aaa/shareSamba valid users = aaa browseable = yes guest ok = no read only = no create mask = 0777

$ sudo /etc/init.d/samba-ad-dc // 삼바 재실행 혹은 $ sudo service smbd stop // start 혹은 restart

후에 윈도우 탐색기에서 \169.254.42.230 접속 ( Username / Password 입력)

TCP/IP Socket 프로그래밍

• bind
• OSI 7 계층 , TCP/IP Protocol

<오후> gpio - v gpio readall

WiringPi를 이용해 구현해보는 Raspberry Pi 예제

LED, 스위치

PINMAP SW 1 | GP4 SW 2 | GP17 SW 3 | GP27 SW 4 | GP22

LED 1| GP23 LED 2| GP24 LED 3| GP25 LED 4| GP1

PIR | GP7

PIEZO| GP12

-- 라즈베리 파이 인터럽트 처리 https://blog.naver.com/simjk98/222175571376

#include <wiringPi.h> #include <stdio.h> #include <stdlib.h>

#define LED_PIN 4

int main(void) { if (wiringPiSetup() == -1) { printf("WiringPi 초기화 실패!\n"); return 1; }

pinMode(LED_PIN, OUTPUT);
for (int i=0; i < 5; i++){
    digitalWrite(LED_PIN, HIGH);
    printf("LED 켜짐\n");
    delay(1000); 

    digitalWrite(LED_PIN, LOW);
    printf("LED 꺼짐\n");
    delay(1000); 
}

return 0;

}

#include <stdio.h> #include <stdlib.h> #include <wiringPi.h>

//gpio 사용 #define LED_PIN 23 #define BUTTON_PIN 4 #define delay_val 300

int main(void){ if (wiringPiSetupGpio() == -1) { printf("GPIO 초기화 실패!\n"); return 1; }

pinMode(BUTTON_PIN, INPUT);
pinMode(LED_PIN, OUTPUT);

while(1){
    if(digitalRead(BUTTON_PIN) == HIGH){
        digitalWrite(LED_PIN, HIGH);
        printf("Button Pushed..! -> LED ON\n");
        delay(delay_val); 
    } 
    else {
        digitalWrite(LED_PIN, LOW);
        printf("LED OFF\n");
        delay(delay_val); 
    }
}

return 0;

}

//ISR(Interrupt Service Routine) 구현 int led1_flag = 0; void sw1_isr(void){ if(led1_flag == 0){ digitalWrite(LED_PIN,HIGH); led1_flag=1; } else { digitalWrite(LED_PIN,LOW); led1_flag=0; } prtintf("SW1 pushed..!!"); }

#include <stdio.h>
#include <pthread.h> // 목적파일 생성시 -lpthread 옵션 넣어주기
#include <unistd.h>

void* thread_main(void *arg){
    int i;
    int cnt = *((int*)arg);
    for(i=0; i<cnt; i++){
        sleep(1);
        puts("running thread\n");
    }
    return NULL;
}

int main(int argc, char *argv[]){
    //printf("%d\n",argc); // result : argc = 1 , argc = 인자들의 갯수 ex)./test a , argc = 2 ./test a,b ,argc = 3

    //for(int i=0;i<argc;i++){
    //    printf("%s\n",argv[i]);} // result : ./test

    pthread_t t_id;
    int thread_param = 5;

    if(pthread_create(&t_id, NULL, thread_main,(void*)&thread_param)!=0){
        puts("pthread_create");
        return -1;
    }

    sleep(10);
    puts("end of main\n");

    return 0;
}

포인터처럼 동작하는 클래스 템플릿으로, 사용이 끝난 메모리를 자동으로 해제, new 키워드를 사용해 기본 포인터가 실제 메모리를 가리키도록 초기화한 후에, 기본 포인터를 스마트 포인터에 대입하여 사용 이렇게 정의된 스마트 포인터의 수명이 다하면, 소멸자는 delete 키워드를 사용하여 할당된 메모리를 자동으로 해제 따라서 new 키워드가 반환하는 주소값을 스마트 포인터에 대입하면, 따로 메모리를 해제할 필요 없음

#pragma once
#include<opencv2/opencv.hpp>

//smart pointer
static cv::Ptr<cv::ml::KNearest> train_knn() {
    cv::Mat digits = cv::imread("digits.png", cv::IMREAD_GRAYSCALE);
    if (digits.empty())return nullptr; 
    cv::Mat train_images;
    cv::Mat train_labels;
    for (int i = 0; i < 50; ++i) {
        for (int j = 0; j < 100; ++j) {
            cv::Mat roi = digits(cv::Rect(j * 20, i * 20, 20, 20));
            cv::Mat roi_float;
            roi.convertTo(roi_float, CV_32FC1);
            cv::Mat roi_flatten = roi_float.reshape(1, 1); 
            train_images.push_back(roi_flatten);
            train_labels.push_back(i / 5);
        }
    }
    cv::Ptr<cv::ml::KNearest> knn = cv::ml::KNearest::create(); //Singular
    knn->train(train_images, cv::ml::ROW_SAMPLE,train_labels);
    return knn;
}

마우스 클릭 감지

static cv::Point point_prev(-1, -1);
static void on_mouse(int event, int x, int y, int flag, void* userdata) {
    cv::Mat src = *(static_cast<cv::Mat*>(userdata));
    if (event == cv::EVENT_LBUTTONDOWN) {
        point_prev = cv::Point(x, y);
    }
    else if (event == cv::EVENT_LBUTTONUP){
        point_prev = cv::Point(-1, -1);
    }
    else if (event == cv::EVENT_MOUSEMOVE && (flag & cv::EVENT_FLAG_LBUTTON)) {
        cv::line(src, point_prev, cv::Point(x, y), cv::Scalar(255, 255, 255), 30, cv::LINE_AA, 0);
        point_prev = cv::Point(x, y);
        cv::imshow("DISPLAY", src);
    }
}

KNN 알고리즘

최근접 알고리즘(KNN 알고리즘)은 분류 알고리즘으로 주변에 가까운 K개의 데이터를 보고 데이터가 속할 그룹을 판단

void do_knn_machine_learning() {
    cv::Ptr<cv::ml::KNearest> knn = train_knn();
    if (knn.empty()) {
        std::cerr << "Train Error" << std::endl;
        return;
    }
    std::cout << "Train finished" << std::endl;
    cv::Mat input_display(200, 200, CV_8UC1);
    cv::namedWindow("DISPLAY", cv::WINDOW_NORMAL);
    cv::setMouseCallback("DISPLAY", on_mouse, (void*)&input_display);
    while (true) {
        int keyboard_key = cv::waitKey();
        if (keyboard_key == 27)break;
        else if (keyboard_key == ' ') { //input space bar
            cv::Mat img_resize;
            cv::Mat img_float; // Matrix to transform CV_32FC1 
            cv::Mat image_flatten;
            cv::Mat resource; // Matrix to save the result
            cv::resize(input_display, img_resize, cv::Size(20, 20), 0, 0, cv::INTER_AREA);
            img_resize.convertTo(img_float,CV_32FC1);
            image_flatten = img_float.reshape(1, 1); //flatten ( 1 x 400 )
            knn->findNearest(image_flatten, 5, resource); // k =5  optionable 3,5,7,9
            std::cout << cvRound(resource.at<float>(0, 0)) << std::endl;
            input_display.setTo(0);
            cv::imshow("DISPLAY", input_display);
        }
    }
    cv::destroyAllWindows();
}

#pragma once
#include <opencv2/opencv.hpp>

void color_split() {
    cv::Mat src = cv::imread("candies.png");
    cv::Mat dst(src.size(), src.type());
    std::vector<cv::Mat>hsv_planes;
    cv::cvtColor(src, dst, cv::COLOR_BGR2HSV);
    cv::split(dst, hsv_planes);
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::imshow("H", hsv_planes[0]);
    cv::imshow("S", hsv_planes[1]);
    cv::imshow("V", hsv_planes[2]);
    cv::waitKey();
    cv::destroyAllWindows();
}

임계값 처리(Threshhold)

바이너리 이미지(binary image)란 검은색과 흰색만으로 표현한 이미지를 만드는 방법으로, 여러 값을 어떤 임계점을 기준으로 두 가지 부류로 나누는 방법을 의미

static void on_threshhold(int position, void* userdata) {
    cv::Mat src = *(static_cast<cv::Mat*>(userdata));
    cv::Mat dst;
}
void using_threshhold() {
    cv::Mat src = cv::imread("sudoku.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::namedWindow("SRC", cv::WINDOW_NORMAL);
    cv::namedWindow("DST", cv::WINDOW_NORMAL);
    cv::imshow("SRC", src);
    cv::createTrackbar("Threshhold", "DST", 0, 255, on_threshhold, (void*)&src);
    cv::setTrackbarPos("Threshhold", "DST", 128);
    cv::waitKey();
    cv::destroyAllWindows();

}

트랙바 설정

static void on_trackbar(int position, void* userdata) {
    cv::Mat src = *(static_cast<cv::Mat*>(userdata));
    int block_size = position;
    if (position % 2 == 0) --position;
    if (block_size < 3) block_size = 3;
    cv::Mat dst;
    cv::adaptiveThreshold(src, dst, 255, \
        cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, block_size, 5.0);
    cv::imshow("DST", dst);
}

적응 임계값 처리

void adapative_threshhold() {
    cv::Mat src = cv::imread("sudoku.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::namedWindow("DST",cv::WINDOW_NORMAL);
    cv::createTrackbar("BlockBuster", "DST", nullptr, 200, on_trackbar, (void*)&src);
    cv::setTrackbarPos("Blocksize", "DST", 11);
    cv::waitKey();
    cv::destroyAllWindows();
}

이미지 침식 & 팽창

void erode_dilate() {
    cv::Mat src{ cv::imread("milkdrop.bmp", cv::IMREAD_GRAYSCALE) };
    if (src.empty())return;
    cv::imshow("SRC", src);
    cv::Mat binary_img;
    cv::threshold(src, binary_img, 0.0,/*0.0 = for "OTSU" */255.0, cv::THRESH_BINARY | cv::THRESH_OTSU);
    cv::Mat dst_erode;
    cv::erode(binary_img, dst_erode, cv::Mat());//DEFAULT 3x3
    for (int i = 0; i < 5; ++i) {
        cv::erode(dst_erode, dst_erode, cv::Mat());
        cv::imshow("ERODE",dst_erode);
        cv::waitKey();
    }
    cv::Mat dst_dilate;
    cv::dilate(binary_img, dst_dilate, cv::Mat());
    for (int i = 0; i < 5; ++i) {
        cv::dilate(dst_dilate, dst_dilate, cv::Mat());
        cv::imshow("DILATE", dst_dilate);
        cv::waitKey();
    }
    cv::destroyAllWindows();
}

오프닝 & 클로징 기법

1. Opening : 연결된 부분을 끊어주는 것, 침식연산 이후 팽창연산으로 구현
   2. Closeing : 끊겨있는 부분을 이어주는 것, 팽창연산 이후 침식연산으로 구현

void open_close() {
    cv::Mat src = cv::imread("milkdrop.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::Mat binary_img;
    cv::threshold(src, binary_img, 0.0, 255.0, cv::THRESH_BINARY | cv::THRESH_OTSU);
    cv::Mat dst_open;
    cv::Mat dst_close;
    cv::morphologyEx(binary_img, dst_open, cv::MORPH_OPEN, cv::Mat(),cv::Point(-1,-1),5);
    cv::morphologyEx(binary_img, dst_close, cv::MORPH_CLOSE, cv::Mat(), cv::Point(-1, -1), 5);
    cv::imshow("SRC", src);
    cv::imshow("B_IMG", binary_img);
    cv::imshow("DST_OPEN", dst_open);
    cv::imshow("DST_CLOSE", dst_close);
    cv::waitKey();
    cv::destroyAllWindows();
}

#pragma once
#include <opencv2/opencv.hpp>

void arithmetic1() {
    cv::Mat src1 = cv::imread("lenna256.bmp", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("square.bmp", cv::IMREAD_GRAYSCALE);

    if (src1.empty() or src2.empty()) return;

    std::cout << src1.size << std::endl; 
    std::cout << src2.size << std::endl;

    cv::Mat dst1;
    cv::add(src1,src2,dst1);
    //cv::Mat dst2 = src2 - src1;
    cv::Mat dst2;
    cv::subtract(src2, src1, dst2);
    cv::Mat dst3;
    cv::absdiff(src1, src2, dst3); //
    cv::Mat dst4;
    cv::namedWindow("ADDWEIGHTED");
    for (double i = 0; i <= 1.0; i = i + 0.2) {
        cv::addWeighted(src1, i, src2, i - 1.0, 0.0, dst4);
        cv::imshow("ADDWEIGHTED", dst4);
        cv::waitKey();
    }
    cv::imshow("DST1", dst1);
    cv::imshow("DST2", dst2);
    cv::imshow("SRC1", src1);
    cv::imshow("SRC2", src2);
    cv::imshow("DST3", dst3);
    cv::waitKey();
    cv::destroyAllWindows();
}

void logical() {
    cv::Mat src1 = cv::imread("lenna256.bmp", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("square.bmp",cv::IMREAD_GRAYSCALE);
    if (src1.empty() or src2.empty())return;
    cv::Mat dst(256, 256, CV_8UC1);
    /*cv::bitwise_and(src1, src2, dst);
    cv::imshow("SRC1", src1);
    cv::imshow("SRC2", src2);
    cv::imshow("DST", dst);*/


    cv::bitwise_or(src1, src2, dst);
    cv::imshow("SRC1", src1);
    cv::imshow("SRC2", src2);
    cv::imshow("DST", dst);
    cv::waitKey();

    cv::bitwise_xor(src1, src2, dst);
    cv::imshow("SRC1", src1);
    cv::imshow("SRC2", src2);
    cv::imshow("DST", dst);
    cv::waitKey();

    cv::bitwise_not(src1, src2, dst);
    cv::imshow("SRC1", src1);
    cv::imshow("SRC2", src2);
    cv::imshow("DST", dst);
    cv::waitKey();

    cv::destroyAllWindows();
}

마우스 감지

static void on_mouse(int, int, int, int, void*);

필터 - 엠보싱

엠보싱 필터링(Embossing Filtering) : 컨벌루션 - 픽셀 간 차이 계산 - 밝기 조절의 순서로 이루어지며 주로 이미지의 경계 및 입체 느낌을 부각시키기 위해 적용

void filter_embossing() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty()) return;
    float fillter_data[] = { -1.0f,-1.0f, 0.0f, -1.0,0.0f,1.0f,0.0f,1.0f,1.0f };

    cv::Mat emboss_kernel(3, 3, CV_32FC1, fillter_data);

    cv::Mat dst;
    cv::filter2D(src, dst, -1, emboss_kernel, cv::Point(-1, -1), 80); // 80 -> ligth up
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

필터 - 블러링

블러링 필터(Blurring Filter) : 컨벌루션 - 픽셀 간의 가중 평균 계산 - 흐리게 만들기의 순서로 진행되며 이미지의 노이즈를 줄이는 데 효과적이다. 주로 이미지에서 잡음을 제거하거나 세부한 텍스처를 흐리게 만들어 감추는 데 사용

void filter_blurring() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::Mat dst;
    float blur_filter[] = { 1 / 9.f,1 / 9.f,1 / 9.f, 1 / 9.f,1 / 9.f,1 / 9.f , 1 / 9.f,1 / 9.f,1 / 9.f };
    cv::Mat dst2(3, 3, CV_32FC1, blur_filter);
    cv::filter2D(src, dst, -1, dst2, cv::Point(-1, -1), 0);
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::waitKey();

    for (int ksize = 3; ksize <= 7; ksize += 2) {
        cv::blur(src, dst, cv::Size(ksize, ksize));
        cv::String desc = cv::format("Mean : %d X %d", ksize, ksize);
        cv::putText(dst, desc, cv::Point(10, 30), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255), 1, cv::LINE_AA);
        cv::imshow("DST", dst);
        cv::waitKey();
    }

    cv::destroyAllWindows();
}

필터 - 가우시안 (블러링)

평균값 필터보다 자연스러운 블러링 결과를 만드는 핕터 ( 주로 평균이 0 ) 가우시안 분포 : 평균을 중심으로 좌우 대칭의 종 모양을 갖는 확률 분포 ( 정규 분포 )

void filter_gaussian() {
    cv::Mat src = cv::imread("rose.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::Mat dst;
    for (int sigma = 1; sigma <= 5; ++sigma) {
        cv::GaussianBlur(src, dst, cv::Size(), static_cast<double>(sigma));
        cv::String text = cv::format("Sigma : %d", sigma);
        cv::putText(dst, text, cv::Point(10, 30), cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(255), 1, cv::LINE_AA);
        cv::imshow(text, dst);
        cv::waitKey();
    }
    cv::destroyAllWindows();
}

필터/샤프닝 - 언샤프 마스크 필터

영상을 더 날카롭게 만듦

void filter_unsharp_mask() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::imshow("SRC", src);
    cv::Mat blurred;
    float alpha = 1.0f;
    for (int sigma = 1; sigma <= 5; ++sigma) {
        cv::GaussianBlur(src, blurred, cv::Size(), sigma);
        cv::Mat dst = (1 + alpha) * src - (alpha * blurred);
        cv::String text = cv::format("Sigma : %d", sigma);
        cv::putText(dst, text, cv::Point(10, 30), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255), 1.0, cv::LINE_AA);
        cv::imshow(text, dst);
        cv::waitKey();
    }
    cv::destroyAllWindows();
}

필터 - 노이즈 가우시안

원본 영상에 잡음의 정도와 평균이 0, 분산이 1인 확률변수를 곱한 값을 더하는 방법으로 생성

void noise_gaussian() {
    cv::Mat src = cv::imread("lenna.bmp",cv::IMREAD_GRAYSCALE);
    cv::Mat dst;

    for (int stddev = 10; stddev <= 30; stddev += 10) {
        cv::Mat noise(src.size(), CV_32FC1);
        cv::randn(noise, 0, stddev);
        cv::add;
        cv::String text = cv::format("STDDEV : %d", stddev);
        cv::putText(dst, text, cv::Point(10, 30), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255), 1, cv::LINE_AA);
        cv::imshow("SRC", src);
        cv::imshow("DST", dst);
        cv::waitKey();
        cv::destroyAllWindows();
    }
}

필터 - 양방향 필터

기준 픽셀과 이웃 픽셀과의 거리, 그리고 픽셀 값의 차이를 함께 고려하여 블러링 정도를 조절하며 엣지가 아닌 부분에서만 블러링 실행

void filter_bilateral(){
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::Mat dst1;
    cv::Mat dst2;

    cv::Mat noise(src.size(), CV_32FC1);
    cv::randn(noise, 0, 5);
    cv::add(src, noise, src, cv::noArray(), CV_8UC1);

    cv::GaussianBlur(src, dst1, cv::Size(), 5); //sigma 5
    cv::bilateralFilter(src, dst2, -1, 20, 5);

    cv::imshow("SRC", src);
    cv::imshow("DST1", dst1);
    cv::imshow("DST2", dst2);

    cv::waitKey();
    cv::destroyAllWindows();
}

필터 - 미디움 필터 (미디언 블러)

미디언 필터(Median filter)는 주변 픽셀들의 값들을 정렬하여 그 중앙값(median)으로 픽셀 값을 대체하며, 소금-후추 잡음 제거에 효과적이지만 화질이 좋지 않음.

void filter_medium() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    cv::imshow("SRC", src);

    int number = static_cast<int>(src.total() * 0.1);
    for (int i=0; i < number; ++i) {
        int x = rand() % src.cols;
        int y = rand() % src.rows;
        src.at<uchar>(y, x) = (i % 2)*255;
    }
    cv::Mat dst1; //Gaussian Blur
    cv::Mat dst2; //Median blur

    cv::GaussianBlur(src, dst1, cv::Size(), 1);
    cv::medianBlur(src, dst2, 3);


    cv::imshow("SRC", src);
    cv::imshow("DST1", dst1);
    cv::imshow("DST2", dst2);
    cv::waitKey();
    cv::destroyAllWindows();
}

어파인 변환

6개의 파라미터를 가지는 어파인 변환 행렬은 이동한 점의 개수가 최소 3개 이상이어야 구할 수 있으며, 이를 통해 영상의 크기, 모양, 방향을 수정할 수 있다.

void affine_transform() {
    cv::Mat src = cv::imread("tekapo.bmp");
    if (src.empty())return;
    cv::Point2f srcPts[3];
    cv::Point2f dstPts[3];
    srcPts[0] = cv::Point2f(0, 0);
    srcPts[1] = cv::Point2f(src.cols - 1.0f, 0.0f);
    srcPts[2] = cv::Point2f(src.cols - 1.0f,src.rows-1.0f);
    dstPts[0] = cv::Point2f(50.0f,50.f);
    dstPts[1] = cv::Point2f(src.cols - 100.0f, 100.0f);
    dstPts[2] = cv::Point2f(src.cols - 50.0f,src.rows- 50.0f);
    cv::Mat M = cv::getAffineTransform(srcPts, dstPts);
    std::cout << M << std::endl;

    cv::Mat dst;
    cv::warpAffine(src, dst, M, cv::Size());
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

이미지 방향전환 ( 90도 Rotate )

void rotate_flip() {
    cv::Mat src = cv::imread("lenna.bmp");

    if (src.empty()) {
        std::cerr << "Failed to load image." << std::endl;
        return;
    }

    cv::Mat dst1;
    cv::Mat dst2;

    // Rotate the image 90 degrees clockwise
    cv::rotate(src, dst1, cv::ROTATE_90_CLOCKWISE);

    // Flip the image horizontally and vertically
    cv::flip(src, dst2, -1);

    cv::imshow("Rotated Image", dst1);
    cv::imshow("Flipped Image", dst2);
    cv::waitKey(0);
    cv::destroyAllWindows();
}

소벨 엣지 검출기

void sobel_edge() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if(src.empty())return;
    cv::Mat dx;
    cv::Mat dy;
    cv::Sobel(src, dx, CV_32FC1,1,0); 
    cv::Sobel(src, dy, CV_32FC1,0,1); 

    cv::imshow("SRC", src);
    cv::imshow("DX", dx);
    cv::imshow("DY", dy);

    cv::Mat mag;
    cv::magnitude(dx, dy, mag);
    //C++ float -> imshow (opencv data)
    mag.convertTo(mag, CV_8UC1);

    cv::imshow("Mag", mag);

    cv::waitKey();
    cv::destroyAllWindows();
}

직선 검출

void hough_lines() {
    cv::Mat src = cv::imread("building.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty())return;
    cv::Mat edge;
    cv::Canny(src, edge, 50, 150);
    cv::imshow("EDGE", edge);
    std::vector<cv::Vec2f> lines;
    cv::HoughLines(edge, lines, 1.0, CV_PI / 180, 230);
    cv::Mat dst;
    cv::cvtColor(src, dst, cv::COLOR_GRAY2BGR); //3channel ( Not colored )

    cv::imshow("DST",dst);
    for (int i = 0; i < lines.size(); ++i)
    {
        float r = lines[i][0];
        float t = lines[i][1];
        double cos_t = cos(t);
        double sin_t = sin(t);
        double x0 = r * cos_t;
        double y0 = r * sin_t;
        double alpha = 1000;
        cv::Point pt1(cvRound(x0 + alpha * (-sin_t)), cvRound(y0 + alpha * cos_t));
        cv::Point pt2(cvRound(x0 - alpha * (-sin_t)), cvRound(y0 - alpha * cos_t));

        cv::line(dst, pt1, pt2, cv::Scalar(0, 0, 255), 2, cv::LINE_AA);
    }
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

원형 검출

void hough_circles() {
    cv::Mat src = cv::imread("coins.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) return;

    cv::Mat blurred; // eliminate noise 
    cv::blur(src, blurred, cv::Size(3, 3));

    std::vector<cv::Vec3f> circles;
    cv::HoughCircles(blurred, circles, cv::HOUGH_GRADIENT,1,50,200,50);

    cv::Mat dst;
    cv::cvtColor(src, dst, cv::COLOR_GRAY2BGR);
    for (auto&& circle : circles) {
        cv::Point center(cvRound(circle[0]), cvRound(circle[1]));
        int radius = cvRound(circle[2]);
        cv::circle(dst, center, radius, cv::Scalar(255, 0, 0), 2, cv::LINE_AA);
    }

    cv::imshow("SRC",src);
    cv::imshow("DST",dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

#pragma once
#include<opencv2/opencv.hpp>
static cv::Mat getGrayHistImage(const cv::Mat& hist);
static cv::Mat calcGrayHist(const cv::Mat& hist);
void example() {
    cv::Mat img1 = cv::imread("lenna.bmp");
    cv::Mat img2;
    cv::cvtColor(img1, img2, cv::COLOR_BGR2GRAY); //BGR -> GRAYSCALE
    cv::imshow("IMG1", img1);
    cv::imshow("IMG2", img2);
    cv::waitKey();
    cv::destroyAllWindows();

}

밝기 조절

void brightness() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty()) return;
    cv::Mat dst(src.rows,src.cols,src.type());
    for (int i = 0; i < src.rows; ++i) {
        for (int j = 0; j < src.cols; ++j) {
            /*uchar temp1 = src.at<uchar>(i, j);
            int temp2 = temp1 + 100;
            if (temp2 > 255) temp2 = 255;
            dst.at<uchar>(i, j) = static_cast<uchar>(temp2);*/
            //or
            //dst.at<uchar>(i, j) = cv::saturate_cast<uchar>(src.at<uchar>(i, j) + 100);
            //int temp = src.at<uchar>(i, j) + 100;
            //dst.at<uchar>(i, j) = temp > 255 > 255 temp < 0 ? 0 : temp;
            dst.at<uchar>(i, j) = src.at<uchar>(i, j) + 100;
        }
    }
    cv::Mat dst2 = src + 100;

    cv::imshow("SRC", src);
    cv::imshow("DST2", dst2);
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

밝기 대조

void contrast() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    float alpha = 1.0f;
    cv::Mat dst = ((1 + alpha) * src - 128 * alpha);
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

히스토그램 사용

void show_hist() {
    cv::Mat src = cv::imread("hawks.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty()) return;
    cv::Mat hist1 = calcGrayHist(src);
    cv::Mat hist_img = getGrayHistImage(hist1);
    cv::imshow("HISTOGRAM", hist_img);
    cv::imshow("SRC", src);
    cv::waitKey();
    cv::destroyAllWindows();
}
cv::Mat calcGrayHist(const cv::Mat& img) {
    cv::Mat hist;
    int channels[] = { 0 };
    int dims = 0;
    int histsize[] = { 256 };
    float graylevel[] = { 0, 256 };
    const float* ranges[] = { graylevel };
    cv::calcHist(&img, 1, channels, cv::noArray(), hist,dims, histsize, ranges);
    return hist;
}

cv::Mat getGrayHistImage(const cv::Mat& hist) {
    double histMax;
    cv::minMaxLoc(hist, 0, &histMax);
    cv::Mat imgHist(100, 250, CV_8UC1, cv::Scalar(255));
    for (int i = 0; i < 256; ++i) {
        cv::line(imgHist, cv::Point(i, 100),\
            cv::Point(i,100 - cvRound(hist.at<float>(i, 0) * 100 / histMax)), cv::Scalar(0));
    }
    return imgHist;
}

void histogram_stretching() {
    cv::Mat src = cv::imread("hawkes.bmp", cv::IMREAD_GRAYSCALE);
    if (src.empty()) return;
    double min = 0.0;
    double max = 0.0;
    cv::minMaxLoc(src, &min, &max);
    cv::Mat dst = ((src - min) / (max - min)) * 255;
    cv::Mat hist1 = calcGrayHist(src);
    cv::Mat hist_img = getGrayHistImage(hist1);
    cv::imshow("SRC", src);
    cv::imshow("DST", dst);
    cv::imshow("HISTOGRAM", hist_img);
    cv::imshow("DST_IMG", getGrayHistImage(calcGrayHist(dst)));
    cv::waitKey();
    cv::destroyAllWindows();
}

#pragma once
#include <opencv2/opencv.hpp>
static void on_mouse(int, int, int, int, void*); // 함수의 원형
static void on_level_changed(int, void*);

void show_camera() {
    cv::VideoCapture cap(0); // 0 index 0 = first Camera, 1 => secondary Camera
    if (cap.isOpened()) {
        std::cout << "Connected" << std::endl;
    }
    else {
        std::cout << "Error Occured" << std::endl;
        return;
    }
    std::cout << "Frame width " << cvRound(cap.get(cv::CAP_PROP_FRAME_WIDTH)) << std::endl;
    std::cout << "Frame Height " << cvRound(cap.get(cv::CAP_PROP_FRAME_HEIGHT)) << std::endl;

    cv::Mat frame;
    cv::Mat inversed_frame;
    cv::namedWindow("FRAME", cv::WINDOW_NORMAL);
    cv::namedWindow("INVERSE", cv::WINDOW_NORMAL);
    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        inversed_frame = ~frame;
        imshow("FRAME", frame);
        imshow("INVERSE", inversed_frame);
        if(cv::waitKey(10) == 27) break; // 27 => ESC
    }
    cv::destroyAllWindows();
}

연결된 카메라 영상연결

void show_movie() {
    cv::VideoCapture cap("stopwatch.avi");
    if (cap.isOpened())
    {
        std::cout << "video is connected" << std::endl;
    }
    else {
        std::cout << "There is no Video" << std::endl;
        return;
    }

    std::cout << cvRound(cap.get(cv::CAP_PROP_FRAME_WIDTH)) << std::endl;
    std::cout << cvRound(cap.get(cv::CAP_PROP_FRAME_HEIGHT)) << std::endl;

    double fps = cap.get(cv::CAP_PROP_FPS);
    std::cout << "FPS : " << fps << std::endl;

    int delay = cvRound(1'000 / fps);

    cv::namedWindow("STOPWATCH", cv::WINDOW_NORMAL);
    cv::Mat frame;

    cv::namedWindow("INVERSE", cv::WINDOW_NORMAL);

    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        cv::imshow("STOPWATCH", frame);
        cv::imshow("INVERSED", ~frame);
        cv::waitKey(delay);        
    }
    cv::destroyAllWindows();
}

연결된 카메라를 통한 녹화 진행

void show_video_record() {
    cv::VideoCapture cap(0);
    if (cap.isOpened())
    {
        std::cout << "Camera is Connected" << std::endl;
    }
    else {
        std::cout << "Camera is Unconnected" << std::endl;
        return;
    }
    double fps = (cap.get(cv::CAP_PROP_FPS));
    int delay = cvRound(1000 / fps);
    int fourcc = cv::VideoWriter::fourcc('X', '2', '6', '4');
    cv::Mat frame;
    cv::Mat inversed;

    // fps 함수 적용 안되면 직접 fps 때려박기..
    cv::VideoWriter output("recording.mp4", fourcc, 30, 
        cv::Size(cap.get(cv::CAP_PROP_FRAME_WIDTH),cap.get(cv::CAP_PROP_FRAME_HEIGHT)));
    if (output.isOpened()) {
        std::cout << "Recording is ready" << std::endl;
    }
    else {
        std::cout << "Recording is not ready" << std::endl;
        return;
    }
    cv::namedWindow("RECORDING");
    while (true) {
        cap >> frame;
        inversed = ~frame;
        if (frame.empty()) break;
        output << inversed; // 영상 저장
        cv::imshow("RECORDING", frame);
        if (cv::waitKey(30) == 27) break;
    }
    cv::destroyAllWindows();
}

선 그리기

void show_draw_lines() {
    cv::Mat canvas(800, 800, CV_8UC3, cv::Scalar(255,255,255));

    cv::line(canvas, cv::Point(50, 50), cv::Point(200, 50), cv::Scalar(0, 0, 255), 10);
    cv::line(canvas, cv::Point(50, 50), cv::Point(200, 100), cv::Scalar(255, 0, 255), 1);

    cv::arrowedLine(canvas, cv::Point(50, 200), cv::Point(150, 200), cv::Scalar(0, 255, 0), 2);
    cv::drawMarker(canvas, cv::Point(30,250),cv::Scalar(0,0,255),cv::MARKER_CROSS);

    cv::namedWindow("CANVAS", cv::WINDOW_NORMAL);
    cv::imshow("CANVAS", canvas);
    cv::waitKey();
    cv::destroyWindow("CANVAS"); 
}

도형 그리기

void show_draw_polygons(){
    cv::Mat canvas = cv::Mat(500,500,CV_8UC3,cv::Scalar(255,255,255));
    cv::rectangle(canvas, cv::Rect(50, 50, 150, 50),cv::Scalar(0,0,255),3);
    cv::rectangle(canvas, cv::Rect(50, 150, 100, 50),cv::Scalar(0,0,255), -1);
    cv::circle(canvas, cv::Point(300, 120), 60, cv::Scalar(255, 255, 0), -1, cv::LINE_AA);
    cv::ellipse(canvas,cv::Point(120,300),cv::Size(60,30),20,0,270,cv::Scalar(0,255,0),-1,cv::LINE_AA);

    std::vector<cv::Point>points;
    points.push_back(cv::Point(250, 250));
    points.push_back(cv::Point(300, 250));
    points.push_back(cv::Point(300, 300));
    points.push_back(cv::Point(350, 300));
    points.push_back(cv::Point(350, 350));
    points.push_back(cv::Point(250, 350));

    cv::polylines(canvas, points, true, cv::Scalar(255, 0, 255), 5, -1);

    cv::namedWindow("CANVAS", cv::WINDOW_NORMAL);
    cv::imshow("CANVAS", canvas);
    cv::waitKey();
    cv::destroyAllWindows();
}

텍스트 삽입

void show_draw_text(){
    cv::Mat canvas = cv::imread("lenna.bmp");
    cv::putText(canvas, "LENNA",cv::Point(250,450),cv::FONT_HERSHEY_TRIPLEX | \
    cv::FONT_ITALIC,2,cv::Scalar(255,0,0),5,-1);
    cv::namedWindow("LENNA", cv::WINDOW_NORMAL);
    cv::imshow("LENNA", canvas);
    cv::waitKey();
    cv::destroyAllWindows;
    }

키보드 입력에 대한 이벤트 (종료)

void keyboard_event(int key) {
    if (key == 27) {
        // ESC 키가 눌렸을 때 프로그램 종료
        std::cout << "ESC 키 눌림. 프로그램 종료." << std::endl;
    }
}

마우스에 입력에 대한 이벤트

static cv::Mat img;
static cv::Point pt_old;
void mouse_event(int event, int x, int y, int flags, void* userdata) {
    if (event == cv::EVENT_LBUTTONDOWN) {
        // 왼쪽 마우스 버튼이 눌렸을 때
        pt_old = cv::Point(x, y);
    }
    else if (event == cv::EVENT_LBUTTONUP) {
        // 왼쪽 마우스 버튼이 떼어졌을 때
        cv::Point pt_new(x, y);
        cv::line(img, pt_old, pt_new, cv::Scalar(0, 0, 255), 2); // 빨간색 선으로 점을 연결
        cv::imshow("Image", img);
    }
}

마우스를 따라 이벤트

void on_mouse(int mouse_event, int mouse_x, int mouse_y, int flags, void* param) {
    // 이 함수는 마우스 이벤트가 발생할 때마다 호출됩니다.

    if (mouse_event == cv::EVENT_LBUTTONDOWN) {
        // 왼쪽 마우스 버튼이 눌렸을 때
        pt_old = cv::Point(mouse_x, mouse_y);
    }
    else if (mouse_event == cv::EVENT_LBUTTONUP) {
        // 왼쪽 마우스 버튼이 떼어졌을 때
        cv::Point pt_new(mouse_x, mouse_y);
        cv::line(img, pt_old, pt_new, cv::Scalar(0, 0, 255), 2); // 빨간색 선으로 점을 연결
        cv::imshow("Image", img);
    }
}

출력 이미지 상단에 Trackbar 생성

void trackbar_event() {
    cv::Mat canvas(800, 800, CV_8UC1);
    cv::namedWindow("CANVAS");
    cv::createTrackbar("Level", "CANVAS", nullptr, 16, on_level_changed, (void*)&canvas);
    cv::imshow("CANVAS", canvas);
    cv::waitKey();
    cv::destroyAllWindows();
}

Trackbar 와 연동해서 레벨에 따라 바뀌도록 함

void on_level_changed(int positition, void* userdata) {
    cv::Mat img = *(static_cast<cv::Mat*>(userdata));
    img.setTo(positition * 16);
    cv::imshow("CANVAS", img); //updating
}

특정 영역의 색을 바꿈

void mask_setTo() {
    cv::Mat src = cv::imread("lenna.bmp");
    cv::Mat mask = cv::imread("mask_smile.bmp",cv::IMREAD_GRAYSCALE);
    if (src.empty() or mask.empty()) return;
    src.setTo(cv::Scalar(0, 255, 0), mask); //mask 의 RGB 값을 src에 적용
    cv::imshow("SRC", src);
    cv::imshow("MASK", mask);
    cv::waitKey();
    cv::destroyAllWindows();
}

OpenCV를 통한 이미지 합성

void mask_copyTo() {
    cv::Mat src = cv::imread("airplane.bmp");
    cv::Mat mask = cv::imread("mask_plane.bmp", cv::IMREAD_GRAYSCALE);
    cv::Mat dst = cv::imread("field.bmp");
    if (src.empty() or mask.empty() or dst.empty()) return;

    cv::imshow("ORIGINAL", dst);
    cv::imshow("SRC", src);
    cv::imshow("MASK", mask);

    src.copyTo(dst, mask);
    cv::imshow("CHANGED", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

실행 소요 시간 측정

void time_inverse(){
    cv::Mat img = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return;
    cv::Mat dst(img.rows, img.cols, img.type());
    cv::TickMeter tick;
    tick.start();
    for (int i = 0; i < img.rows; ++i) {
        for (int j = 0; j < img.cols; ++j) {
            dst.at<uchar>(i, j) = 255 - img.at<uchar>(i, j);
        }
    }
    tick.stop();
    std::cout << "걸린 시간 : " << tick.getTimeSec() << "초" << std::endl;
    cv::imshow("IMG", img);
    cv::imshow("DST", dst);
    cv::waitKey();
    cv::destroyAllWindows();
}

min & max 함수

void useful_funtions() {
    cv::Mat src = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    std::cout << static_cast<int>(cv::sum(src)[0]) << std::endl;
    std::cout << static_cast<int>(cv::mean(src)[0]) << std::endl;

    double min_value = 0.0;
    double max_value = 0.0;

    cv::Point min_point;
    cv::Point max_point;

    std::cout << "Min : " << min_value << " , " << "Max : " << max_value << std::endl;
    cv::minMaxLoc(src, &min_value, &max_value, &min_point, &max_point);
    std::cout << "Min : " << min_value << " , " << "Max : " << max_value << std::endl;
    std::cout << "Min Poisition X: " << min_point.x << " , " << "Min Position: " << min_point.y << std::endl;
    std::cout << "Max Poisition X: " << max_point.x << " , " << "Max Position: " << max_point.y << std::endl;

}

#pragma once
#include <opencv2/opencv.hpp>
#define SEMICOLON ;  // Macro Function
#define PI 3.141592 ; 
#define SQUARE(x) ((x*x))
void show_code_3() {
    cv::Point pt1; //default constructor
    pt1.x = 5;
    pt1.y = 10;
    cv::Point pt2(pt1); // copy constructor
    cv::Point pt3 = pt1 + pt2;
    int dot1 = pt1.dot(pt2); // inner product

    std::cout << pt2 << std::endl;

    cv::Size sz1(10, 20);
    cv::Size sz2;
    cv::Size sz3 = sz1 + sz2;
    int sz4 = sz1.area();

    std::cout << sz1 << std::endl;

    cv::Rect rc1(0, 10, 0 + 60, 10 + 30);
    cv::Rect rc2 = rc1 + cv::Size(50, 40);
    cv::Rect rc3 = rc2 + cv::Point(60, 60);

    cv::Mat mat1(800, 800, CV_8UC1, cv::Scalar(255)); //CV_8UC1 = OpenCV type ( type for imshow())
    std::cout << "[ 10 , 20 ] : " << static_cast<int>(mat1.at<uchar>(10, 20)) << std::endl;

    cv::Mat mat2(255+cv::Mat::zeros(900, 900, CV_8UC1));

    cv::Mat Mat3(255 * cv::Mat::ones(900, 900, CV_8UC1));
    cv::Mat mat4(255 * cv::Mat::eye(900, 900, CV_8UC1));
    cv::imshow("Mat", mat4);
    cv::waitKey();
    cv::destroyAllWindows();

}

얕은 복사 & 깊은 복사 예시

void show_code_3_8() {
    cv::Mat img1{ cv::imread("dog.bmp") }; // c++11 uniform initializer
    if (img1.empty()) {
        std::cout << "No file" << std::endl;
        return;
    }
    std::cout << img1.size << std::endl;

    cv::Mat img2 = img1; //copy constructor , shallow copy

    cv::Mat img3 = img1.clone(); //deep copy

    cv::imshow("IMG1", img1);
    cv::imshow("IMG2", img2);
    cv::imshow("IMG3", img3);
    cv::waitKey();

    img1.setTo(cv::Scalar(0, 255, 255)); // 원본 이미지 변경 

    cv::imshow("IMG1", img1);
    cv::imshow("IMG2", img2);
    cv::imshow("IMG3", img3);
    cv::waitKey();

    cv::destroyAllWindows();
}

Image 비트 반전 예시

void show_code_3_9() {
    cv::Mat img1 = cv::imread("cat.bmp");
    if (img1.empty())
    {
        std::cout << "There is no file exist" << std::endl;
        return;
    }
    cv::Mat img2 = img1(cv::Rect(270, 120, 340, 240)); //() -> operator overloading
    cv::Mat img3 = img1(cv::Rect(270, 120, 340, 240)).clone(); //() -> deep copy
    img2 = ~img2; // not , bit 반전

    cv::imshow("IMG1", img1);
    cv::imshow("IMG2", img2);
    cv::waitKey();
    cv::destroyAllWindows();
}

get & set 함수 구현

void show_code_3_10() {
    cv::Mat mat1(cv::Mat::zeros(10,10,CV_8UC1));
    for (int i = 0; i < mat1.rows;++i) {
        for (int j = 0; j < mat1.cols; ++j) {
            std::cout << static_cast<int>(mat1.at<uchar>(i, j)) << "\t"; //get
        }
        std::cout << std::endl;
    }

    std::cout << "=========================================" << std::endl;
    uchar value{ 0u };
    for (int i = 0; i < mat1.rows; ++i) {
        for (int j = 0; j < mat1.cols; ++j) {
            mat1.at<uchar>(i, j) = ++value; //set
        }
        std::cout << std::endl;
    }

}

행렬을 이용한 이미지 표현

void show_code_3_13() {
    cv::Mat img1 = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    cv::Mat img2;
    img1.convertTo(img2, CV_32FC1);
    uchar data1[] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    cv::Mat mat1(3, 4, CV_8UC1, data1);

    std::cout << mat1 << std::endl;
    cv::Mat mat2 = mat1.reshape(0, 1);
    std::cout << mat2 << std::endl;

    cv::Mat mat3 = cv::Mat::ones(1, 4, CV_8UC1) * 255;
    mat1.push_back(mat3);
    /*cv::imshow("IMG", img2);
    cv::waitKey();
    cv::destroyAllWindows();*/
}

RGB 값을 이용한 이미지 생성

void show_code3_16() {
    cv::Scalar blue = 128;
    std::cout << "blue : " << blue << std::endl;
    cv::Scalar yellow(0, 255, 255);
    std::cout << yellow << std::endl;
    cv::Mat img1(800, 800, CV_8UC3, yellow);

    cv::imshow("IMG1", img1);
    cv::waitKey();
    cv::destroyAllWindows();
}

Matter 표준의 동작 방식

1. IP Protocol 기반으로 동작 -> 개별 Device가 각각의 IP를 지님

Wifi 나 Thread 같은 통신 Protocol을 기본적으로 지원

2. 응용계층(Application Layer) 표준

3. 네트워크 모습

Matter는 CSA에 의해 관리되고 Apache 2.0에 따라 라이선스가 부여되며 CSA에서는 회원이 자체 Matter 준수 장치 개발을 지원하기 위해 사용할 수 있는 표준 구현 및 애플리케이션 라이브러리를 유지 및 관리한다. 보안 및 사용자 개인정보 보호는 Matter의 주요 관심사이며, 라이브러리는 Matter 장치 환경 전반에서 일관된 보안 구현을 보장한다. 하드웨어의 측면에서 Matter는 엔드 노드, 에지 노드, 게이트웨이(컨트롤러라고도 함), 브리지, 경계 라우터를 포함합니다. 게이트웨이와 경계 라우터를 모두 ‘허브’라고도 하므로 혼동될 수 있으므로 구분

현재 Matter 의 버전은 1.1이다. 관련 영상

이미지 열기

#pragma once   //header 의 중복 선언 방지
#include <opencv2/opencv.hpp>
void show_images()
{
    cv::Mat img = cv::imread("lenna.bmp", cv::IMREAD_GRAYSCALE);
    cv::Mat img2 = cv::imread("dog.bmp", cv::IMREAD_COLOR); //Default 가 Color
    if (img.empty() or img2.empty()) {
        std::cout << "image file does not exist" << std::endl;
        return 1;
    }
    cv::namedWindow("LENNA", cv::WINDOW_NORMAL);
    cv::namedWindow("DOG"); //WINDOW_NORMAL is default
    cv::imshow("LENNA", img);
    cv::imshow("DOG", img2);
    cv::waitKey(); // waitKey(1000) = 1sec
    cv::destroyAllWindows();
}

정적 바인딩( static binding ) vs 동적 바인딩( dynamic binding )

• *바인딩 ( binding ) * : 프로그램 소스에 쓰인 각종 내부 요소, 이름 식별자들에 대해 값 또는 속성이 확정되어 변경할 수 없어 묶이게(bind) 되는 과정(binding)

• 정적 바인딩( static binding ) : 프로그램 소스에 명시적으로 타입과 그 타입의 변수 명을 선언 컴파일 시 점프할 주소가 바인딩되며 비교적 속도가 빠르고 타입 오류시 해결이 쉬움

  // 정적 바인딩 예시 "int" 라는 타입과 "a"라는 변수명을 가짐
  int main()
  {
    int a = 0 
  }
  

• 동적 바인딩( dynamic binding ) : 실행(Runtime) 도중에 바인딩하므로 소스코드를 줄일 수 있고 유연하지만 정적 바인딩에 비해 실행 속도가 느리며 메모리 낭비가 발생할 수 있다.

  class A
  {
   virtual void print() {}
  }
  class B : A
  {
   override void print() {}
  }
  int main()
  {
   A* a = new A();
   a->print();
  
   B* b = new B();
   a = b;
   a->print();
  }
  

Function Overloading Vs Function Overriding

Abstract Base Class [ABC]

• 순수 가상함수(Pure virtual function) virtual Animal Lion = 0 의 형태를 취하며 파생 클래스에서 재정의가 가능하다.

• 추상 클래스 ( Abstract Class ) 는 하나 이상의 순수 가상함수를 가지며, 이 클래스로 부터 파생된 클래스는 반드시 가상함수를 재정의 해야한다.

< In-line function >

• C++ 에서의 함수 호출 과정

1. 함수의 호출 -> 스택에 함수로 전달할 매개변수와 함께 호출이 끝난 뒤 돌아갈 반환 주소값을 저장

2. 프로그램의 제어가 함수의 위치로 넘어와 함수 내에 선언된 지역 변수도 스택에 저장

3. 함수의 모든 코드를 실행 -> 실행 후 반환값을 넘겨 줌

4. 프로그램의 제어는 스택에 저장된 돌아갈 반환 주소값으로 이동, 스택에 저장된 함수 호출 정보를 제거

인라인 함수(In-line function)은 위 과정을 거치지 않고 실행하기 위해서 inline 키워드를 이용해 사용

int min(int x, int y)         -> inline int min(int x, int y)
{                                {
    return x > y ? y : x;           return x > y ? y : x;
}                                }


int main()
{
    std::cout << min(5, 6) << '\n';
    std::cout << min(3, 2) << '\n';
    return 0;
}

매크로 함수 ( Macro function )

/* Macro function 예시 */
#include <stdio.h>
#define square(x) x *x  

int main(int argc, char **argv) {
  printf("square(4) : %d \n", square(4));

  return 0;
} 

#define square(x) x*x처럼 매크로 함수는 #define 함수명(인자) 치환할 것으로 선언 따라서 위 실행 결과는 16이 된다.

네임스페이스 ( Namespace )

• Namespace 란 C++에서는 변수, 함수, 구조체, 클래스 등을 서로 구분하기 위해서 이름으로 사용되는 다양한 내부 식별자(identifier)를 가지고 있지만 프로그램이 복잡해지고 외부 라이브러리가 많아지게 되면 충돌할 가능성이 생기므로 충돌하지 않기 위해 만들어진 개념
• 헤더 파일에서 정의
• using 키워드 사용시
  1. using 지시자 : using namespace (네임스페이스 이름);
     2. using 선언 : using 네임스페이스이름::이름;

다시 써보기

Queue() {} // 기본 생성자 Queue(const Queue& rhs){ memberwise copy } // 복사 생성자 ~Queue() {} //소멸자 Queue& operator=(const Queue& rhs) { memberwise copy } // 대입 연산자 오버로딩 Queue operator&() {} // *주소 연산자 오버로딩 const Queue operator&() const{} // *주소 연산자 오버로딩

explicit (명시적)

explicit을 알기 위해선 C++ Compiler 에서 일어나는 암시적 변환(implicit conversion)에 대해서 알아야 한다.

• 숫자 승격 (numeric promotion) 한 자료형의 값이 더 큰 유사한 자료형의 값으로 변환하는 경우로 데이터 손실 없음

long   l(64);    // int -> long
double d(0.12f); // float -> double

• 숫자 변환 (numeric conversion) 큰 자료형의 값이 더 작은 유사한 자료형의 값으로 변환하거나 서로 다른 자료형 간에 변환하는 경우, 데이터 손실이 일어날 수도 있음

double d = 3; // int -> double ( type 이 다른 경우) 
short s = 2; // int -> short (더 큰 자료형에서 작은 자료형으로)

C++ 에서는 explicit 키워드를 통해서 암시적 변환을 할 수 없도록 컴파일러에게 알려 줄 수 있다.

extern

extern 은 다른 cpp에 존재하는 전역변수를 참조할 때 사용하거나, 외부에 있는 함수를 가져올 때 사용한다.

+) extern "C" 는 C++ 컴파일러가 정의된 함수 혹은 헤더파일에 대해 맹글링하지 말라는 의미

상속 (inherit)

• 상위(부모/기초) 클래스의 내용 ( 속성, 메소드 ) 를 하위(자식/파생) 클래스가 물려받는 것

• 접근제어 지시자 1.public : 어디에서든 멤버 변수와 메소드에 접근 가능

  class Example : public p_class /*상속 선언시 private를 제외하고 상속 */

  2.private : 외부에서는 접근 불가

  class Example : public p_class /*상속 선언시 private를 제외한 것들을 private로 상속 */

  3.protected : 하위(자식)클래스 에서만 해당 멤버 변수에 접근 가능하고 외부는 접근불가

  class Example : protected p_class /*상속 선언시 public을 protected로 바꿔 상속 */

• 상속의 조건

  1. is a

     Lion is a Animal
     Panda is a Animal /*Lion 과 Panda 는 Animal 이라는 기초 클래스를 상속하는 유도클래스이다.*/

     is a의 조건으로는 상속관계가 있을 때, 아래로 갈 수록 구체화 혹은 특수화(Specialization)가 되어야하며 위로 갈 수록 일반화(Generalization)되어야한다.

  파생클래스는 기본클래스의 모든 특성을 포함하기에 is a관계로 포함.

  2. has a has a의 조건으로는 객체 멤버에 의한 포함관계나 객체 포인터 멤버에 의한 포함관계가 있다. 상속으로 묶인 두개의 클래스는 결합도가 강해지고 많은 제약을 줄 수있다.

다형성(Polymorphism)

1. 다양한 형태를 가지는 성질로써, 상위 클래스에 가상 멤버 함수(virtual member function)가 있어야 함
2. 하위 클래스에서 오버라이딩할 멤버함수가 없다면 상위 클래스의 소멸자를 가상함수로 만든다.
3. 객체는 상위 클래스의 포인터나 참조자로 만들어야 함 virtual 키워드로 상위 클래스의 멤버함수 선언시 override 된 하위 클래스의 멤버함수를 사용가능
   4. 상위 클래스의 멤버함수에는 없는 하위 클래스의 멤버함수를 사용하려면 다운캐스팅해야함 typeid를 사용할 때에는 객체이거나 정의된 클래스로 자료형에 대한 정보 얻을 수 있음

1. 도우미 함수 (helper func)

1. 도우미 함수는 최종 사용자가 인스턴스화하지 않지만 내부적으로 다른 클래스 내에서 사용되는 유용한 기능을 제공하는 함수
2. 함수가 클래스의 멤버가 아니라 다른 클래스인 경우 C++ 프로그램은 다른 목적으로 데이터를 인쇄하거나 사용하는 도우미 함수를 생성
3. 도우미 함수는 일반적으로 클래스의 작성자가 제공해 클래스의 표현에 직접 액세스할 필요가 없다.

Compiler 가 생성해주는 Member func ( Default 생성자는 다른 생성자가 존재하면 생성안됨)

1. 디폴트 생성자(Default Constructor):
   • 클래스에 생성자가 정의되지 않은 경우, 컴파일러는 디폴트 생성자를 자동으로 생성
   • 디폴트 생성자는 객체를 초기화

class Array {
public:
    Array() { // 디폴트 생성자
    }
};

2. 복사 생성자(Copy Constructor):
   • 클래스의 객체가 다른 객체로 복사될 때, 컴파일러는 복사 생성자를 자동으로 생성.
   • 이 복사 생성자는 얕은 복사(shallow copy)를 수행하며, 필요에 따라 사용자 정의로 오버로딩할 수 있음

class Array {
public:
    Array(const Array& rhs) { // 복사 생성자
    }
};

3. 대입 연산자 오버로딩(Assignment Operator Overloading):
   • 객체가 다른 객체에 대입될 때, 컴파일러는 대입 연산자를 자동으로 생성
   • 사용자 정의로 대입 연산자를 오버로딩하여 객체의 멤버 변수를 올바르게 복사하도록 할 수 있음

class Array {
public:
    Array& operator=(const Array& rhs) { // 대입 연산자 오버로딩
    }
};

4. 소멸자(Destructor):
   • 클래스에 사용자 정의 소멸자가 없는 경우, 컴파일러는 기본 소멸자를 자동으로 생성
   • 소멸자는 객체가 파괴될 때 자동으로 호출되며, 메모리나 리소스의 정리를 수행하는 데 사용

class Array {
public:
    ~Array() { // 소멸자
    }
};

2 . Name Mangling

컴파일 과정에서 식별자(Identifier)는 같지만 다른 namespace에 속해 있거나, 다른 시그니쳐를 가지는 경우(ex. function overloading) 고유한 이름을 가지게 하기 위해 호출 규약(calling convention) 등에 따라서 함수나 변수의 이름을 컴파일러가 변경하는 것

C언어에서는 name magling이 없으므로 extern "C"를 사용하여 C++ 컴파일러(현재 실행중인 프로그램 체계)에게, C로 작성한 코드이니 C문법을 적용하여 컴파일하라는 의미를 알려준다. 정확히 말하면, C++의 변수 맹글링(오버로딩)아닌 C의 변수 맹글링(동일한 함수명 사용 문법, 오버로딩 하지 않음)을 적용하라는 의미

3. ++a ,a++ 구현 a++와 ++a는 C++ 및 다른 C 기반 프로그래밍 언어에서 사용되는 증가 연산자(Increment Operator)입니다. 이 두 연산자는 변수의 값을 증가시키는 역할을 한다

1. a++ (후위 증가 연산자, Post-increment):
   • a++는 변수 a의 현재 값을 사용한 후에 a를 1 증가
   • a의 현재 값을 반환하고, 그 다음에 a가 1 증가

int a = 5;
int b = a++; // b는 5가 되고, a는 6이 됨

2. ++a (전위 증가 연산자, Pre-increment):
   • ++a는 변수 a를 1 증가시킨 후에 a의 증가된 값을 사용
   • a를 1 증가시킨 후에 그 증가된 값을 반환

int a = 5;
int b = ++a; // a와 b 모두 6이 됨

1. 생성자

1. 기본 생성자 (Default Constructor):
   • 매개변수를 가지지 않는 생성자
   • 클래스가 다른 생성자를 가지지 않을 때 자동으로 제공
   • 객체를 생성할 때 호출되며, 주로 멤버 변수를 기본값으로 초기화하는 데 사용

class Complex {
public:
    Complex() { // 기본 생성자
    }
};

2. 매개변수가 있는 생성자 (Parameterized Constructor):
   • 하나 이상의 매개변수를 가지는 생성자
   • 객체를 생성할 때 호출되며, 매개변수를 사용하여 멤버 변수를 초기화할 수 있다

class Complex {
public:
    Complex(double re, double im) { // 매개변수가 있는 생성자
    }
};

3. 복사 생성자 (Copy Constructor):
   • 다른 객체로부터 생성자가 호출되는 생성자
   • 객체를 복사하거나 객체를 인수로 받는 함수 호출 시 자동으로 호출

class Complex {
public:
    Complex(const Complex& rhs) {
        // 복사 생성자
    }
};

4. 복사 할당 연산자 (Copy Assignment Operator):
   • 다른 객체의 값을 현재 객체에 할당
   • 객체의 복사본을 생성하는 대신 기존 객체의 값을 업데이트

class Complex {
public:
    Complex& operator=(const Complex& rhs) {
        // 복사 할당 연산자
        if (this != &rhs) {
            // 자기 자신과의 할당을 방지
        }
        return *this;
    }
};

• 생성자의 무한복사 : Call by Reference(&)가 아닌 Call by value 일때 복사 생성자를 호출하면, 외부에서 객체를 복사 생성 -> 복사생성자 호출 -> 매개변수를 값으로 전달받을 경우 호출하는 쪽으로부터 매개변수가 복사 생성 -> 복사생성자 호출 -> 무한 반복....

2. 얕은 복사 & 깊은 복사

1. 깊은 복사 (Deep Copy) :

   • 깊은 복사는 복사 대상 객체의 모든 데이터나 멤버 변수를 완전히 복사
   • 새로운 객체를 생성하고, 원본 객체의 모든 데이터를 복사하거나 복제합니다.
   • 객체 내에 포인터 또는 동적 할당된 자원이 있는 경우, 깊은 복사는 해당 자원을 새로 할당하여 복사합니다.
   • 따라서 깊은 복사를 수행한 후에는 원본과 복사본이 완전히 독립적이며, 한 쪽을 수정해도 다른 쪽은 영향을 받지 않는다

2. 얕은 복사 (Shallow Copy) :

   • 얕은 복사는 복사 대상 객체의 주소만 복사하는 것을 의미
   • 복사본은 원본 객체와 동일한 데이터나 멤버 변수를 가리키며, 데이터나 멤버 변수를 공유
   • 만약 객체 내에 포인터나 동적 할당된 자원이 있다면, 원본과 복사본이 같은 자원을 가리킴
   • 이로 인해 한 객체에서 자원을 수정하면 다른 객체에서도 동일한 자원이 수정

3. Complex c4 = c3, c4=c3의 차이 :

   • Complex c4 = c3 : 객체 c3를 사용하여 객체 c4를 초기화하는 과정으로 생성자 또는 복사 생성자를 호출하여, c4를 c3와 동일한 값으로 초기화시키며 복사 초기화 또는 객체 초기화라고 한다

   Complex c4 = c3; // 복사 초기화

   c3와 c4는 별도의 독립적인 객체므로 변경이나 수정은 각 객체에 영향을 주지 않는다

2. c4 = c3 : 이미 생성된 객체 c4에 객체 c3의 값을 할당 -> 할당 연산이라고 한다

   c4 = c3; // 할당 연산

   c3의 값이 c4에 복사되는 것을 의미하고 변경하면 한 객체가 다른 객체에 영향을 미칠 수 있다

3. 함수중복

 class Complex{
 public:
    Complex()
    Complex(double re)
    complex(double re,double im)
 // 함수 이름을 같게 하되 입력 받는 매개변수를 다르게 함으로 써, 함수를 정의 

4. 디폴트 인수 ( Default Argument )

1. 디폴트 인수(default argument)는 기본값이 미리 정의되어 있는 인수를 의미

2. 함수를 호출할 때 인수를 전달하지 않으면, 함수는 자동으로 미리 정의되어 있는 디폴트 인수값을 사용

Complex(),Complex(double re), Complex(double re,double im) -> Complex(double re = 0.0 , double im = 0.0)로 대체 가능

friend

1. friend 는 클래스의 멤버 함수가 다른 클래스의 비-멤버 함수를 호출하도록 허용하는 기능을 ->friend 함수는 클래스의 private 또는 protected 멤버에 접근할 수 있도록 허용

2. 두 클래스 간의 밀접한 관계: 두 클래스가 서로 밀접하게 관련되어 있으며 한 클래스가 다른 클래스의 비공개 멤버에 접근해야 하는 경우 friend 키워드를 사용

3. 연산자 오버로딩: 연산자 오버로딩 함수 중에서 두 개 이상의 클래스의 비공개 멤버에 접근해야 하는 경우에 friend 키워드를 사용

friend 함수를 정의할 때에는 해당 함수가 어떤 클래스의 friend인지를 지정해야 합니다. friend 함수는 클래스의 정의 내부 또는 외부에서 정의할 수 있으며, 함수 정의에서 friend 키워드를 사용하여 해당 클래스를 선언합니다.

class String{
friend std::ostream& operator<< (std::ostream& out, const String& rhs);
private:
}

+) 마주한 Error

• undefined reference to~ : header에는 선언 되었지만 cpp파일에는 없을 때 나오는 에러...

1. Code Section (Text Section)

• 프로그램의 명령어들이 저장되며 프로세스 종료까지 유지되는 영역
• 프로그램 코드가 저장되며, 프로그램이 실행되면 CPU에 의해 실행 -> Compile 이후 기계어로 저장
• 읽기 전용으로 설정되어 있어 프로그램이 이 영역의 내용을 수정할 수 없다.

• 작업이 들어오면 access violation 발생 읽기 전용일때의 장점 : 한 종류의 프로그램을 여러 번 혹은 여러 개 실행해도, 공유가 가능

2. Data Section

• 초기화된 전역(global) 변수와 정적(static) 변수들이 저장되는 영역 -> 상수, 포인터 변수의 값, 배열의 값, 구조체의 값
• 프로그램의 시작과 함께 할당되며, 프로그램의 종료 시까지 유지

3. BSS (Block Started by Symbol) Section

• Data Section 에 포함됨
• 초기화되지 않은 전역 변수와 정적 변수가 저장되는 영역 -> (포인터 변수,배열,구조체)의 초기값 포함
• 프로그램이 시작되면 메모리가 할당되고 초기화되지 않은 변수들은 자동으로 초기화

4. Heap

• 동적으로 메모리를 할당하고 해제하는 데 사용되는 영역
• 사용자가 직접 제어하여 메모리 할당과 해제가 가능
• 메모리의 크기와 위치는 런타임에 동적으로 결정
• new, malloc 를 사용하여 힙에 메모리를 할당 delete, free 등을 사용하여 해제
• C++의 경우에는 garbage collector 가 활동하면 자동으로 반환하는 경우도 있음
• Heap 의 크기가 작으면 Heap Overflow가 발생할 수 도 있음

5. Stack

• 스택은 함수 호출과 로컬 변수들의 저장에 사용되는 영역, 완료시 소멸
• 함수가 호출될 때마다 스택 프레임이 생성되며, 해당 함수의 지역 변수와 매개변수가 저장
• 함수가 종료되면 함수의 반환 값이 Stack에 저장되며, 해당 스택 프레임이 제거
• 후입선출(LIFO) 구조
• Stack 의 크기가 작으면 Stack Overflow가 발생할 수도 있음

*연산자(Operator) : * 특정한 작업을 수행하는 기호 또는 함수로 사용자 정의 연산자도 생성 가능

1. 산술 연산자 (Arithmetic Operators):

   • +: 덧셈
   • -: 뺄셈
   • *: 곱셈
   • /: 나눗셈
   • %: 나머지

2. 할당 연산자 (Assignment Operators):

   • =: 대입
   • +=: 덧셈 후 대입
   • -=: 뺄셈 후 대입
   • *=: 곱셈 후 대입
   • /=: 나눗셈 후 대입
   • %=: 나머지 후 대입

3. 비교 연산자 (Comparison Operators):

   • ==: 동등
   • !=: 부등
   • <: 작다
   • >: 크다
   • <=: 작거나 같다
   • >=: 크거나 같다

4. 논리 연산자 (Logical Operators):

   • &&: 논리적 AND
   • ||: 논리적 OR
   • !: 논리적 NOT

5. 증감 연산자 (Increment and Decrement Operators):

   • ++: 증가
   • --: 감소

6. 비트 연산자 (Bitwise Operators):

   • &: 비트 AND
   • |: 비트 OR
   • ^: 비트 XOR
   • ~: 비트 NOT
   • <<: 비트를 왼쪽으로 이동
   • >>: 비트를 오른쪽으로 이동

7. 조건(삼항) 연산자 (Conditional (Ternary) Operator):

   • condition ? value_if_true : value_if_false: 조건이 참이면 첫 번째 값, 거짓이면 두 번째 값 반환

8. 멤버 접근 연산자 (Member Access Operators):

   • .: 멤버 접근 (객체)
   • ->: 멤버 접근 (포인터)

9. 포인터 연산자 (Pointer Operators):

   • *: 포인터 역참조
   • &: 주소 참조

10. 타입 변환 연산자 (Type Conversion Operators):

    • static_cast: 정적 타입 변환
    • dynamic_cast: 동적 타입 변환 (상속 관련)
    • const_cast: 상수 제거 변환
    • reinterpret_cast: 재해석 변환

연산자 중복 (Operator Overloading) : 기존의 연산자를 사용자 정의 데이터 유형에 대해 새로 정의하거나 확장

예를 들어, 두 개의 객체를 더하는 연산자 +를 사용자 정의 클래스에 대해 사용하고자 할 때, 연산자 중복을 이용할 수 있습니다.

//연산자 중복
std::cout << "Hello World" << std::endl;
operator<<(std::cout,"Hello World").operator<<(std::endl); 

함수 중복(Function Overloading): 같은 이름의 함수를 여러 번 정의하는 기능 동일한 이름의 함수를 다양한 매개변수 목록과 타입에 대해 정의 가능 호출 시 전달되는 인자에 따라 적절한 함수가 자동으로 선택되어 실행

예를 들어, 동일한 함수 이름으로 여러 개의 함수를 정의하여 다양한 데이터 유형에 대해 동작을 제공할 수 있습니다.

//<complex.h>
#ifndef COMPLEX_H
#define COMPLEX_H

class Complex{
private:
    double re;
    double im;
public:
    Complex();
    Complex(double re);
    Complex(double re, double im);
    ~Complex();
    double real();
    double imag();
    void real(double re);
    void imag(double im);
};

위에서는 Complex 함수를 인자가 없는 Complex() 와 실수형을 받는 Complex(double re) 와 Complex(double re, double im) 로 만들어 준었다.

*Reference(aliasing) vs pointer *

레퍼런스(참조):

• 레퍼런스는 반드시 초기화되어야 하며 선언과 동시에 변수에 바인딩
• 초기화되면 다른 변수에 바인딩되지 않음
• 널 포인터 문제와 같은 오류를 방지해 포인터보다 안전하게 사용가능
• 자동으로 간접 참조되므로 포인터 연산이 필요하지 않음
• 주로 함수의 매개변수로 전달하거나 함수의 반환 값으로 사용

포인터:

• 주소를 저장하는 변수 로 직접적인 메모리 주소를 가리킴
• 초기화하지 않거나 널 포인터(NULL 포인터)로 초기화할 수 있습니다.
• 여러 변수들과 공유 될 수 있습니다.
• 포인터 연산을 사용하여 간접 참조 , 값을 변경할 수 있음
• 동적 메모리 할당, 배열 처리, 객체의 동적 변화 의 경우에 더 적합

값에 의한 호출 (Call by value)

• 함수에 전달되는 인자의 값을 복사하여 함수 내부에 새로운 변수로 사용하므로, 함수 내에서 인자의 값이 변경되더라도 원본 변수는 영향을 받지 않음
• 호출된 함수 안에서 매개변수로 전달된 값은 로컬 변수로 취급 -> 수정해도 원본 값에는 영향을 미치지 않음.

** 참조에 의한 호출 (Call by Reference) :**

• 함수에 전달되는 인자의 메모리 주소를 전달 -> 함수 내부에서 인자의 값이 변경되면 원본 변수도 변경
• 호출된 함수 안에서 매개변수로 전달된 레퍼런스를 통해 값에 접근하면, 원본 변수의 값이 직접 수정

1. from C to C++

1. 확장자의 변경 from (.c) to (.cpp)

   // Ubuntu OS 
   cp (디렉토리 지정)/ main.c main.cpp
   cp (디렉토리 지정)/stack.h stack.h
   cp (디렉토리 지정)/stack.c stack.cpp

   // How to Compile in UbuntuOs
   g++ -c stack.cpp
   g++ -c main.cpp
   g++ -c stack.h
   g++ -o testStack main.o stack.o

   gedit으로 편집 : gedit main.cpp stack.h stack.cpp

2. push(&s1,100) -> s1.push(100)

1. 멤버함수는 반드시 객체를 통해서 호출한다 예시) s1.pop(), s2.pop()
2. 모든 멤버함수는 자신과 호출된 객체를 가리키는 this 포인터를 갖는다.
3. 데이터와 관련된 연산은 같은 멤버로 구성, 캡슐화(encapsulation)

//수정 전 코드
#include <stdio.h>
#include "stack.h"

int main(void)
{
    Stack s1, s2;
    initStack(&s1, 10);
    initStack(&s2, 100);

    push(&s1, 100);
    push(&s1, 200);
    push(&s1, 300);

    printf("s1 1st pop() : %d\n", pop(&s1));
    printf("s1 2nd pop() : %d\n", pop(&s1));
    printf("s1 3rd pop() : %d\n", pop(&s1));


    push(&s2, 900);
    push(&s2, 800);
    push(&s2, 700);

    printf("s2 1st pop() : %d\n", pop(&s2));
    printf("s2 2nd pop() : %d\n", pop(&s2));
    printf("s2 3rd pop() : %d\n", pop(&s2));

    cleanupStack(&s1);
    cleanupStack(&s2);
    return 0;
}

int main() {
    Stack s1(10);
    Stack s2(100);

    s1.push(100);
    s1.push(200);
    s1.push(300);

    printf("s1 1st pop() : %d\n", pop(&s1));
    printf("s1 2nd pop() : %d\n", pop(&s1));
    printf("s1 3rd pop() : %d\n", pop(&s1));

    s2.push(900);
    s2.push(800);
    s2.push(700);

    printf("s2 1st pop() : %d\n", pop(&s2));
    printf("s2 2nd pop() : %d\n", pop(&s2));
    printf("s2 3rd pop() : %d\n", pop(&s2));

3. malloc() / free() 함수 --> new / delete 연산자

malloc() / free() 와 new / delete 에 대한 비교

1. 메모리 할당:

   • C (malloc): malloc() 함수는 동적으로 메모리를 할당하기 위해 사용 ex) int* ptr = (int*)malloc(sizeof(int)); malloc()은 할당한 메모리의 크기만큼의 바이트를 할당, 초기화 X

   • C++ (new): new 는 C++에서 동적으로 메모리를 할당하기 위해 사용 ex) int* ptr = new int; new는 할당한 메모리를 초기화하며, 객체의 경우 생성자도 호출

2. 메모리 해제:

   • C (free): free()는 malloc()으로 할당된 메모리를 해제하는 데 사용 ex)free(ptr); free()를 호출하면 해당 메모리 블록 해제, 포인터 유효하지 않음
   • C++ (delete): delete는 new로 할당된 메모리를 해제하는 데 사용 ex)delete ptr; delete를 호출하면 해당 객체의 소멸자가 호출, 할당된 메모리 블록이 해제,포인터는 더 이상 유효하지 않음

3. 배열 할당 및 해제:

   • C (malloc + free): C에서 배열을 할당하려면 malloc()을 사용해야 하며, 해제할 때는 free()를 사용

   • C++ (new[] + delete[]): C++에서 배열을 할당하려면 new[] 를 사용하고, 해제할 때는 delete[] 를 사용 new[]로 할당된 배열은 해당 크기 정보와 함께 메모리에 저장 delete[]를 호출하면 배열의 각 요소에 대해 소멸자가 호출되며 할당된 메모리 블록이 해제

4. 예외 처리:

   • C (malloc + free): malloc()과 free()는 예외 처리를 지원하지 않아 메모리 할당 또는 해제 과정에서 문제가 발생하면 프로그램이 비정상적으로 종료될 수 있다.

   • C++ (new + delete): new와 delete는 C++에서 예외 처리를 지원함 할당 또는 해제 중에 문제가 발생하면 예외가 throw되어 적절한 예외 처리 메커니즘을 통해 처리가능

//수정 전 코드 <stack.cpp>
#include <stdlib.h>
#include <assert.h>
#include "stack.h"

void initStack(Stack *ps, int size)
{
    ps->pArr = malloc(sizeof(int) * size);
    assert(ps->pArr /* != NULL */);

    ps->size = size;
    ps->tos = 0;
}

void cleanupStack(Stack *ps)
{
    free(ps->pArr);
}


void push(Stack *ps, int data)
{
    assert(ps->tos != ps->size);

    ps->pArr[ps->tos] = data;
    ++ps->tos;
}

int pop(Stack *ps)
{
    assert(ps->tos /* != 0 */);

    --ps->tos;
    return ps->pArr[ps->tos];
}

//수정 후 코드
#include <cassert> // <cassert> 로 변경
#include "stack.h"

class Stack {
private:
    int* pArr;
    int size;
    int tos;

public:
    Stack(int s) : size(s), tos(0) {
        pArr = new int[size]; // malloc() 에서 new[]로 변경
    }

    ~Stack() {
        delete[] pArr; // free()에서 delete[]로 변경
    }

    void push(int data) {
        assert(tos != size);
        pArr[tos] = data;
        ++tos;
    }

    int pop() {
        assert(tos != 0);
        --tos;
        return pArr[tos];
    }
};

4. 구조체 멤버에 접근지정자 ( private / public ) 를 사용

1. 내부구현(implemetation)은 숨기고, 인터페이스는(interface)는 보인다.

2. 허용된 연산을 통해서 내부 구현에 접근할 수 있다.
   • 정보 은닉(information/data hiding) == 캡슐화(encapsulation)

//수정 후 코드
#include <cassert> // <cassert> 로 변경
#include "stack.h"

class Stack {
private: //private로 지정 클래스 내부에서만 사용 가능
    int* pArr;
    int size;
    int tos;

public: // public 으로 지정 클래스 외부에서도 사용 가능
      Stack(int s) : size(s), tos(0) {
          pArr = new int[size]; 
      }

    ~Stack() {
          delete[] pArr; 
      }

    void push(int data) {
          assert(tos != size);
          pArr[tos] = data;
          ++tos;
      }

5. 생성자(Constructor) / 소멸자(Destructor)

1. 생성자 : 객체가 생성될 때, 자동적으로 호출되는 멤버함수

2. 소멸자 : 객체가 소멸될 때, 자동적으로 호출되는 멤버함수

// 수정 후 코드
public: 
//생성자로써 initStack(Stack *ps,int size)에서 Stack(int s)으로 변경
      Stack(int s) : size(s), tos(0) { 
          pArr = new int[size]; 
      }
//소멸자로써 void cleanupStack(Stack *ps) 에서 Stack()으로 변경
    ~Stack() {
          delete[] pArr; 
      }

6. struct --> class

class(C++) = struct(C) + 멤버함수 + 접근지정자

C의 struct와 C++의 class는 모두 데이터와 함수를 하나의 유닛으로 그룹화하는데 사용되지만, C++의 class는 더 많은 기능과 특성을 제공하여 객체 지향 프로그래밍의 원칙을 더 쉽게 적용할 수 있도록 한다.

1. 캡슐화 (Encapsulation):

   • C의 struct: C의 struct는 멤버 변수만을 가지며, 함수를 정의할 수 없다. 데이터의 그룹화는 가능하지만, 해당 데이터를 다루는 함수를 함께 묶을 수 없음

   • C++의 class: C++의 class는 멤버 변수와 멤버 함수를 함께 포함하여 객체의 상태와 동작을 하나로 묶을 수 있다. 이를 통해 데이터와 데이터를 다루는 동작을 함께 캡슐화하여 더 모듈화된 코드를 작성할 수 있다.

2. 접근 제어 (Access Control):

   • C의 struct: C의 struct는 기본적으로 모든 멤버가 public으로 설정되어 외부에서 멤버 변수에 직접 접근이 가능하며, 캡슐화의 개념이 부족

   • C++의 class: C++의 class는 기본적으로 모든 멤버가 private으로 설정, 이를 통해 외부에서 직접적으로 접근하는 것을 제한하고, public, private, protected 등의 접근 제어 지시자를 사용하여 적절한 접근을 조절

3. 생성자와 소멸자 (Constructor and Destructor):

   • C의 struct: C의 struct는 생성자와 소멸자를 가질 수 없다. 초기화 작업과 정리 작업을 구현할 수 없다.

   • C++의 class: C++의 class는 생성자와 소멸자를 가질 수 있다. 객체의 초기화와 정리 작업을 효과적으로 관리할 수 있습니다.

4. 상속 (Inheritance)과 다형성 (Polymorphism):

   • C의 struct: C의 struct는 상속과 다형성을 지원하지 않는다.

   • C++의 class: C++의 class는 상속과 다형성을 지원하여 객체 지향 프로그래밍의 핵심적인 개념을 적용할 수 있다.

5. 멤버 함수 및 멤버 변수의 초기화:

   • C의 struct: C의 struct는 멤버 변수를 초기화하지 않아 사용자가 수동으로 초기화해야 함

   • C++의 class: C++의 class는 생성자를 통해 멤버 변수를 초기화할 수 있다. 이를 통해 객체 생성 시 초기값을 제공하거나, 초기화 로직을 더 효과적으로 관리할 수 있다.

간단하게 말해, C++의 class는 C의 struct보다 객체 지향 프로그래밍을 더 쉽게 적용하도록 해주는 다양한 특성과 기능을 제공, C++의 class를 사용하면 코드의 모듈화, 캡슐화, 상속, 다형성 등을 더 효과적으로 활용할 수 있다.

7. printf() --> cout << ??

1. std::cout (C++)은 <iostream>헤더에 속하며, 스트림의 유형의 객체이다. 출력하려는 값의 자료형을 컴파일러가 검사할 수 있다.

   std::cout << 2 << endl; //int형 출력 함수 호출
   std::cout <<"2"<< endl; //string형 출력 함수 호출

   • 파일 입출력(fstream) 스트링 입출력(stringstream)에서도 표준 입출력과 동일한 인터페이스를 사용하므로 편리함, printf()에 비해 속도가 느림
   • endl사용
2. printf()는 <cstdio>헤더에 속하며, 형식화된 문자열을 표시하는데 주로 사용 cout과 달리 출력하려는 값의 자료형을 컴파일 할 수 없기 때문에, 버그가 일어날 수 있지만, cout에 비해 처리 속도가 빠르다.

• \n사용