반응형

C++11 :  범위기반 for 문

배경

 이미 C++11에서부터 존재했지만, 신경을 안쓰면 잘 모르는 for문의 기능이다. 이미 다른 언어들은 기존부터 foreach라는 키워드로 제공했던 기능이다.


 for문에서 직접 범위기반으로 반복하는 것이 가능 해짐으로써 STL 컨터이너 사용에 좀 더 편리 해졌다.



사용방법

#include <iostream>
#include <vector>

int main(const int argc, const char * argv[])
{
    std::vector<int> vec{ 1, 2, 3, 4};
    // 기존 반복자 사용방법
    auto itVec = vec.begin();
    for(; itVec != vec.end(); ++itVec)
    {
        std::cout << (*itVec) << std::endl;
    }

    // 범위 for문
    for(auto valVec : vec)
    {
        std::cout << valVec << std::endl;
    }
    return 0;
}


 첫 for문은 반복자를 이용한 원소 출력인 반면, 두번째 for문은 범위를 이용해서 원소를 확인하는 방법이다. auto 키워드는 C++11에서 가장 먼저 사용하게 되기때문에 자세한 설명은 생략한다.(auto 링크)



주요 특징

 1. 기존 반복자를 사용하지 않고 시퀀스(메모리가 연결된 자료형)형 컨테이너의 원소를 확인을 할 수 있다.
 2. 읽는 원소는 시퀀스 내부 원소의 형으로 변환된다.

 3. 범위 for문을 사용하여 읽는 시퀀스내부의 원소 값을 수정할 수 없다.



참조자료

MSDN 범위기반 for문




반응형
반응형

C++11 : STL std::array 정적배열

배경

 C++11에서 등장한 array는 기존의 정적 배열(이제는 C Style array 라고 불림)을 개선하기 위해서 등장을 했다. C/C++ 외의 다른 프로그래밍 언어를 조금 훝어보면 알 수 있다.


 JAVA, JS, C# 등에서의 배열을 선언/정의 할때 부가 정보(Length 등)가 같이 있는 것에 비해서 C++11이전의 C Style static array은 단순히 연속된 메모리 공간의 앞부분을 가르키는 포인터에 불과 했었다. 이로 포인터를 사용할 경우 잘못된 메모리 참조 또는 이를 개선하기 위한 추가 코딩으로 인한 생산성 저하로 이어지는 문제가 있다.


 그래서 C++11이전에서는 std::vector를 사용하기도 했다. 그러나 C Style Array에 비해서 성능 저하의 부담이 크며, 오버플로워가 일어나면, 동적으로 용량을 늘려 버리는 바람에 정해진 크기를 버퍼로 사용하기에는 잠재적인 문제가 있을 수 있다(물론 좋은 프로그래머는 이런 문제를 예방을 할 것이다).


 std::array는 vector보다 경량이며, 기존의 정적 배열의 성질을 가졌으며, 반복자등 일부 STL 컨테이너를 사용할 수 있게 만들어졌다.



선언 및 초기화 방법

 array표준헤더파일을 포함해야 사용할 수 있다. 타입과 배열크기를 입력하고 기존 컨테이너처럼 선언하고 사용할 수 있다. <>에 첫인자는 자료형(type), 두번째 인자는 크기를 입력해야 한다.

#include <array>

int main(const int argc, const char * argv[])
{
    std::array<int, 5> arr1 = {1, 2, 3};
    std::array<int, 5> arr2(1, 2, 3);
    std::array<int, 5> arr3{1, 2, 3};

    return 0;
}


주요 특징

 정의된 array의 남는 원소에는 0으로 초기화가 된다.

 array도 vector와 같이 객체명(혹은 변수명) 뒤에 대괄호로 배열처럼 사용할 수 있다.

 vector처럼 반복자를 사용할 수 있다.


예시

// arrayEx.cpp
#include <array>
#include <iostream>

int main(cosnt int argc, const char * argv[])
{
    std::array<int, 5> arr1{1, 2, 3};
    // 네번째 int에 접근하여 값을 대입함
    arr1[3] = 4;
    // 반복자처럼 사용 가능
    auto itArr = arr1.begin();
    for(; itArr != arr1.end(); ++itArr)
    {
        std::cout << (*itArr) << std::endl;
    }
    // 출력결과 arr1[4](5번째)는 0으로 초기화 되어 있음
    return 0;
}


 size() 함수로 배열의 크기를 알 수 있다. 단, capacity()가 없다. 이는 vector와 가장 큰 차이 중 하나다. 이는 array경우 size()와 capacity()가 따로 있을 필요가 없기 때문이다.

 array로 선언된 객체명은 array라는 컨테이너의 포인터이기이다. 이 때문에 기존의 정적 배열의 첫번째 포인터가 필요할 경우 vector와 같이 data()를 호출해서 사용해야 한다. 이는 오래된 라이브러리를 호환해야 한다던가 버퍼로 사용하기에 적절하다.

 fill()로 특정 원소값으로 모든 원소를 초기화 할 수 있다.


이 밖의 자세한 특징은 cpprefernce 문서를 참조하면 된다.



참조자료

cppReference 문서




반응형
반응형

C++ 컴파일 에러 : cannot bind ~

에러 메시지

cannot bind 'std::basic_ostream<char>' lvalue to 'std::basic_ostream<char>&&'


발생하는 사례

 보통 cout 표준 클래스에서 자주 발견된다. 뿐만 아니라 연산자 오버라이딩이 된 클래스를 사용하다 보면 종종 발생된다.


에시1

// c++11 more than
#include <iostream>

using namespace std;

enum class COLOR
{RED, GREEN, BLUE};

int main(const int argc, const char * argv[])
{
    cout << "Color enum Red : "
        << static_cast<int>(COLOR::RED) << endl;    // No Error
    cout << "Color enum Green : " << COLOR::GREEN << endl;    // Error!
    return 0;
}




예시2

 이 예시는 보기 조금 민망하다..

// c++11 more than
#include <iostream>
#include <vector>

using namespace std;

int main(const int argc, const char * argv[])
{
    cout << "vectors : " << vector<int>{1, 2, 3} << endl;    // Error!
    return 0;
}




원인

 입출력 관련 클래스가 연산자 오버라이딩이 가능해지면서 직관적으로 코드를 작성할 수 있게 되었는데, 그러다 보니 정의 되지 않은 타입을 연산자로 받을 경우 발생되는 간단한 에러이다. 별거 아닌 에러이지만, 사람이 종종 실수를 할 수 있기 때문에 볼 수 있다. 다만, 메시지의 의미를 파악하는 연습을 하도록 하자.

 해결 방법은 연산자가 이해할 수 있는 타입으로 캐스팅을 해주거나 연산자 오버라이드를 추가 해주면 된다. 이 글을 작성하는 시점에서는 이런 실수를 방지 하기 위해 연산자 오버라이딩은 가능하면 자제하는 추세인걸로 알고 있다.


참고자료

스택오버플러워 질문



반응형

'C++' 카테고리의 다른 글

C++11 : 범위기반 for 문  (0) 2018.03.04
C++11 : STL std::array 정적배열  (0) 2018.03.04
C++ Socket : 고정 구조체  (0) 2017.08.04
C++11 : 연역적 선언 auto (입문)  (0) 2017.07.03
C++ 패턴 : 동적 싱글턴(Dynamic Singleton)  (0) 2017.06.16
반응형

C++ Socket : 고정 구조체

알게된 배경

 기존 소켓 교재들 대부분이 C로 되어 있는것을 접하다가 C++로 옮기고 나서 소켓 프로그램을 작성할때에 구조체의 크기가 C와 같이 연속적인 형태로 메모리에 저장되지 않는다는 것을 알게 되었기에 기록으로 남긴다.


C Style Struct?

 이제는 고유 키워드가 되어 버렸다. C만 기본적으로 메모리에 직접적으로 올라가는 듯 하다. 혹은 라이브러리로 혹은 이후 표준으로 확장이 되는지 앞으로 확인이 필요할 듯하다.

 이유는 메모리에 사용자가 로드하는 대로 하지 않는 이유는 성능을 향상시키기 위해서 하는 작업이기 때문이다. 성능을 중요시한다면, 후에라도 지원이 될 듯 하지만.. C의 언어 철학은 프로그래머를 믿으라는 것이 모토이기 때문에 안될 가능성도 있다.


키워드

각 컴파일별로 선언하는 방식이 다르다. GCC 컴파일러 기준으로는 언더바로 확장된 키워드를 사용한다. __attribute__((__packed__))를  struct 와 이름 사이에 넣으면 된다.

GCC 예시)

// Header.hpp
struct __attribute__((__packed__)) SHeader
{
    char name[4];
    int32_t number;
    int32_t body_sz;
};



메모리 로드

 만약 키워드가 없을 경우에는 문자열과 숫자형을 구분하여 8바이트 단위로 메모리에 로드하게 된다. 


 예제 예시로 설명하자면, 편의상 8바이트 단위를 row라고 하면, row1에 name[4]가 로드되고 row2에 number, body_sz가 로드되어서 row가 2개이므로 총 16바이트를 차지하게 된다.

 따라서 __attribute__ 를 사용해서 실제 내부 총량이 메모리에 로드되는 것과 동일하게 하면, 12바이트가 된다(소켓 프로그램에서는 이렇게 되어야 한다).


이러한 이유로 일반적인 PC간의 소켓 통신을 할경우 헤더같이 struct로 자료형을 만들 경우 가능하면 8바이트로 딱떨어지는 형태가 되는 것이 성능저하가 적을 것이라 예측이 되는 요소이다(대부분 운영체제는 현시점에서 8바이트 형태로 최적화 되어 있는 듯 하다. 물론 이는 절대적이지 않다).


(MVC++(Microsoft Visual C++)컴파일러의 경우 다른 방법이 있는 것으로 알고 있는데, 정리할 때 메모부분을 분실해서 추후에 추가하기로 기약한다.)


여담

 C++98 이후 부터 성능을 올리기 위해서 도입이 된 것같다.

 이런식으로 언더바(_) 두개를 이용한 새로운 키워드로 기능을 확장을 하고 있는 추세이기 때문에 변수 선언시 언더바 사용을 자제할 것을 권장하고 있다. C#에서는 클래스 멤버변수를 선언시 언더바를 아직 사용하는 경향이 있지만, C++에서는 언더바 사용을 안하고 반만 헝가리식으로 소문자 m을 붙이는 경향도 있다. 어찌 되었든 권장이니 꼭 따를 필요는 없고 프로젝트 규약에 주의하자.


참고자료

스택오버 플로워


반응형
반응형

C++11 : 연역적 선언 auto (입문)

알게된 배경

 혼자 프로젝트를 진행을 하다 보니 가능하면 최신(2017년에 2011년에 재정된 표준을 사용하는 것이 과연 최신 일까?) 표준을 사용하기 위해서 공부하면서 알게 된 것들이다. 최신 기술이 항상 좋은 건 아니지만, 새로운 기술은 항상 이전 기술을 사용하면서 축적된 경험으로 부터 개선점이 나오기 때문에 반대로 나쁘다고만 할 수 도 없고 생각든다.

 해당 내용은 effective modern c++를 많이 참조했다.


auto 키워드

 C++98 에서도 존재하던 키워드였지만, C++11에서 급진적으로 바뀐 키워드중 하나다. 즉, C++98에도 역할이 다른 키워드이니 C++11을 경계로 이전 버전에서는 호환이 안된다. 다만, 다행스러운건 이전 버전에서는 거의 사용이 안되던 키워드였기 때문에 웬만하면 큰 문제가 발생되지 않는다.


 적절한 한글 명칭으로는 '연역적 형식선언' 정도 붙일 수 있다. auto 키워드는 JS와 C#에 존재하는 var와 유사한 역할을 한다. 즉, 객체 혹은 변수를 선언할때 초기화 하는 값에 의해서 형이 정해지는 것이다.

예시)

int a1 = 10;
auto a2 = 10;    // a1 == a2

int b1;
b1 = 10;
auto b2;    // error
b2 = 10;




 초기화 하는 형이 있어야 형을 선언할 수 있기 때문에 반드시 초기화를 해야 하며, auto 키워드는 변수형 뿐만 아니라 객체로도 사용되기 때문에 STL의 iterator를 선언할 경우 상당히 많은 코드를 줄일 수 있다.

예시)

std::vector<int> arrVec = {1, 2, 3, 4, 5};
std::vector<int>::iterator it1 = arrVec.begin();
auto it2 = arrVec.begin();
// it1[1] == it2[1]




장점

 auto 를 사용함으로써 얻는 장점은 3가지로 자주 언급이 된다.

1. 코드의 길이가 줄어듬

2. 초기화 강제화로 실수가 줄어듬

3. 코드의 유지보수(리펙토링)가 쉬워짐

4. 형 선언 실수를 방지할 수 있음


사실 STL의 자료형을 많이 사용해본 입장에서는 1, 2번의 장점이 매우 크게 느껴진다.


단점

1. 대리자(proxy) 형식 때문에 형식을 잘못 연역하는 경우가 있음

2. 코드만 봤을때 직관적이지 않음(이는 IDE의 부가 기능으로 어느정도 해결 할 수 있음)


 1번의 경우 대표적인 예로 vector<bool> 형이 많이 거론된다. bool 값은 추상적으로 1비트로 표시할 수 있기 때문에 vector 템플릿은 bool 형을 받으면 비트형으로 저장을 하게 된다. 즉, vector<bool> bVec(5)를 선언하면, bVec는 1바이트의 5비트를 갖고 있는 것이다. 문제는 C++은 바이트 단위로 처리를 하기 때문에 bool형은 실제로 바이트로 되어 있는데, 이러한 자료형의 이질성을 해소하기 위해 중간에 대리자라는 형식이 존재한다.


 문제는 이렇게 중간에 껴있는 대리자를 통하여 포인터를 넘겨 받을 경우 대리자가 어떻게 구현되었는지에 따라 영향을 받게 된다. 이러한 경우 경우에 따라 연역적 형 선언에 실패하게 된다. 따라서 이러한 경우 명시적으로 선언을 해줘야 한다.


결론

 이러한 auto 키워드 사용은 권장이지 의무는 아니다. 하지만, 장점과 단점을 생각해서 사용하는 것이 더욱 즐겁고 효율적인 코딩이 될 것이다.


참조자료

Effective Modern C++

반응형
반응형

C++ 패턴 : 동적 싱글턴(Dynamic Singleton)

정리하게 된 배경

 은근히 자주 사용되지만, 가끔 기억이 안나서 잘 못 작성한 코드의 오류를 한참 고민을 했기 때문에 후에 있을 시간을 절약하기 위해 기록을 한다.


싱글턴 패턴

 영문으로는 Singleton이라 하기 때문에 싱글톤이라 표기 한곳도 의외로 많지만, 위키백과에서는 싱글턴으로 표기를 하기 때문에 여기서는 싱글턴으로 표기를 하였다. 싱글턴 패턴도 여러 종류가 있지만, 실용적으로 자주 사용되는 동적 싱글턴 패턴에 대해서 소스코드를 적는다.


 싱글턴 패턴은 이름에서도 알 수 있 듯이 하나만 있다는 의미를 내포하고 있다. 즉, 실질적인 객체는 오직 하나이다. 싱글턴 객체를 사용하기 위해서는 싱글턴 내부에 선언되어 있는 인스턴스객체에 접근해서 사용이 가능하다. C/C++에서는 포인터의 개념을 들어 설명을 하면 이해가 쉽지만(물론 포인터를 이해했다는 전제하에) 포인터가 없는 다른 언어에서는 종종 인스턴스 참조와 인스턴스 생성간 혼란이 있는 듯하다.

 

 논리(이론)적 구성은 단하나의 객체 혹은 인스턴스가 존재해야 하며, 추가로 선언을 못하게 해야 한다. 여기서 동적 싱글톤의 경우 프로그램 시작과 관계없이 싱글턴의 인스턴스를 받아오려는 순간 생성이 되어 생성시점이 동적인 특징이 있다.


소스코드


// Singleton.hpp
#include <iostream>

class Singleton
{
private:
    Singleton(void);
    ~Singleton(void);
    static Singleton* _instance;
public:
    static Singleton* getInstance(void);
    void print(void);
};


// Singleton.cpp
#include "Singletion.hpp"

using namespace std;

Singleton* Singleton::_instance = nullptr;

Singleton* Singleton::getInstance(void)
{
    if(nullptr == _instance)
        _instance = new Singleton;
    return _instance;
}

void Singleton::print(void)
{
    cout << "singletion!" << endl;
}


// main.cpp
#include "Singleton.hpp"

Singleton* ins = Singleton::getInstance();
ins->print();
// or
Singleton::getInstance()->print();


주의할 점

 파일을 hpp에서 getInstance()를 정의할 경우에는 상관이 없지만, cpp에서 정의를 할 경우 static 키워드가 앞에 있어서는 안된다. 만약 사용한다면 문법적인 오류로 에러 메시지를 확인하게 된다.


참고자료

경험




반응형
반응형

gcc C++ : 유닉스 라이브러리 만들기 입문

알게된 배경

 리눅스 환경에서 처음에는 간단한 프로그램을 제작을 했지만, 점차 커기게 되자 상당히 많은 양의 파일들이 한폴더에 어지럽게 있자 더 이상 모듈화를 하지 않으면 코드관리가 안될만한 상황이 되어 라이브러리 작성법에 대해서 공부하게 되었다.


염두해야 될 것

 윈도우 개발환경과 달리 리눅스환경의 경우 gcc의 옵션을 활용하는 방법을 알아야 했다. 그리고 편하게 하려면, makefile을 활용해야 하고, 더 편하게 makefile을 만들기 위해서는 makefile을 어느정도 알고 있는 상태에서 cmake를 사용할 줄 알아야 한다.


테스트 샘플 코드

// ~/lib_test/include/sample.h
#pragma once
#inlcude <iostream>

class Sample
{
public:
    Sample(void);
    ~Sample(void);

    void print(void);
};
// ~/lib_test/src/sample.cpp
#include "../include/sample.h"

using namespace std;

Sample::Sample(void)
{}
Sample::~Sample(void)
{}
void Sample::print(void)
{
    cout << "hello snupy?!" << endl;
}
// ~/lib_test/main.cpp
#include "include/sample.h"

int main(int argc, char* argv[])
{
    Sample sam;
    sam.print();
    return 0;
}



정적 라이브러리

 파일 확장자는 a(Archives의 앞글자)이며, object(.o) 파일과 큰 차이는 없다. 정적라이브러리를 통해서 빌드된 프로그램에 정적라이브러리가 포함되기 때문에 프로그램의 용량이 커지는 특징이 있다. 라이브러리에 수정할 내용이 있어서 수정하게 되면, 프로그램을 다시 빌드해야 하는 단점이 있다.


만드는 방법

# ~/lib_test/ 에서 실행할 경우
g++ -c ./src/sample.cpp -o ./obj/sample.o
ar rc ./lib/libsample.a ./obj/sample.o

 첫 줄은 sample.cpp를 sample.o 로 빌드가 되며, 두번째 줄은 libsample.a로 정적 라이브러리로 만들어준다. ar의 명령어는 아카이브(Archives)의 앞의 두글자를 딴 것이다. 또한 리눅스에서는 파일이름앞에 lib를 붙여야 나중에 실행 파일을 빌드할 때 lib로 인식을 하니 붙여줘야 한다.

 만약 해당 코드에 C++11이상 같은 표준라이브러리을 사용한다면, 오브젝트(.o)파일로 빌드할 때 -std=c++11 같은 옵션을 추가해주어야 한다.


링크된 실행파일 만들기

# ~/lib_test/ 에서 실행할 경우
g++ -o test main.cpp -Llib -lsample

 위의 명령어는 main.cpp라는 소스코드를 test라는 이름으로 빌드를 하게 된다. 이때 lib라는 폴더에 있는 sample이라는 이름의 라이브러리를 참조하라는 명령이 된다. 앞에서 작성한 libsample.a 파일을 sample이라는 라이브러리로 인식을 하게 된다.

 정적 라이브러리는 빌드 이후에는 실행파일에 포함이 되기 때문에 빌드이후 sample.a가 없어도 실행이 된다.


공유 라이브러리

 윈도우의 dll(동적 라이브러리)와 비슷한 개념이다. 때문에 공유 라이브러리를 동적 라이브러리라 부르는 곳도 있다. 확장자는 .so(Share Object의 각 앞글자 머리) 공유 라이브러리의 가장 큰 특징은 정적 라이브러리와 달리 특정 공유 라이브러리 파일만 교체를 해도 수정된 내용이 적용이 된다. 즉, 실행파일을 재 빌드할 필요가 없다(물론 파일이 삭제되거나 추가되면 어쩔 수 없이 재컴파일해야 한다).

 이러한 특징으로 나온 개념이 플러그인 이다(라고 많은 책이나 참고자료가 언급한다).


만드는 방법

# ~/lib_test/ 에서 실행할 경우
g++ -fPIC -c ./src/sample.cpp -o ./obj/sample.o
g++ -shared -o ./lib/libsample.so ./obj/sample.o

 첫줄은 고정된 파일로 컴파일을 하여 오브젝트 파일로 빌드를 한다. 이후 두번째 명령에서는 공유 오브젝트 파일을 생성한다. 여기서는 간단히 확장자를 so로 작성했지만, 보통 프로그램 버전을 관리 할 경우 so.1.0.0 이런식으로 숫자를 뒤에 붙여서 관리를 한다. 또한 -Wl 옵션을 사용하여 추가 옵션을 붙이는 경우가 많다(입문자에게는 이러한 부분이 오히려 진입장벽을 높이는 결과가 되는 것 같다)


링크된 실행 파일 만들기

# ~/lib_test/ 에서 실행할 경우
g++ -o test main.cpp -Llib -lsample

 앞의 링크된 실행파일을 만드는 것과 큰 차이가 없다. 하지만, 이렇게 만들어진 실행파일은 바로 실행할 수 없는데, 이유는 정적 라이브러리와 달리 공유 라이브러리는 실행파일에 포함이 안되어 있기 때문에 실행에 필요한 파일을 알려줘야 한다. 여기서 -L옵션은 빌드할때만 사용되는 라이브러리 경로이다.


 다만, 윈도우즈의 동적 라이브러리인 dll의 경우 보통 실행파일이 있는 폴더와 하위 폴더, 그리고 환경변수에 등록된 폴더에서 실행에 필요한 dll파일이 있는지 찾아서 실행한다.


 반면 리눅스 환경에서는 그냥 환경변수만 찾아 본다(어떤이는 이를 버그라 생각을 한다). 따라서 환경변수에 있는 폴더 경로에 공유 라이브러리를 복사하는 방법과 환경변수를 만들어서 등록해줘야 된다.

 때문에 실행하기 전에 ldd 명령어를 통해 의존성 검사로 파일을 실행하는데 필요한 공유 라이브러리가 연결되어 있는지 확인 할 수 있다.

# ~/lib_test/ 에서 실행할 경우
ldd ./test

 이렇게 확인한 의존성 검사에서 "not found"가 없어지도록 해야 실행이 가능해진다.

 공유 라이브러리를 이용해 배포했을 경우 해당 프로그램을 유지 및 삭제 관리를 할 때 어떻게 할 것인지도 고민을 해야 한다.


환경변수 추가 등록

export LD_LIBRARY_PATH = [라이브러리절대경로]


 환경변수를 통해서 라이브러리 위치를 찾을 수 있다면, ldd로 검사했을 때 not found가 더 이상 보이지 않을 것이다. 실행했을 프로그램의 결과가 보이면 성공적으로 라이브러리를 생성하고 실행을 해본 것이다.


 하지만, LD_LIBRARY_PATH라는 환경변수는 디버그용(배포 전단계의 실행 테스트)에서 사용할 것을 권하지 배포하는 방법으로는 적합하지 않다.


보충해야 될 내용

 여기까지 혼자서 테스트 해보는데 성공했다면, gcc에 대한 옵션에 대해서 추가로 살펴봐야 한다. 당연한 소리지만, 테스트 결과 -l 옵션을 여러번 사용해서 여러개의 라이브러리를 참조하는 것이 가능하다. 또한 옵션을 사용하는 경우가 많으니 gcc 옵션에 대해서도 어느 정도 숙지를 하고 있어야 한다.


참고자료

우분투 환경에서 C언어로 배우는 리눅스 프로그래밍(서적)

옵션에 대한 정리(영문)

옵션에 대해 한글로 자주 사용하는 것만 정리(간혹 오역도 보인다)



반응형
반응형

STL C++ : vector 중복원소 제거

알게된 배경

 한대의 관리 PC에서 여러대의 디바이스 리눅스 계열 운영체제에 접속하는 디바이스 IP 리스트를 관리하기 위해서는 중복으로 접속을 하면 안되기 때문에 중복 검사하는 알고리즘이 필요 하게 되었었다. 일단 이 디바이스 정보들은 vector에 읽어놓은 상태이다(list를 사용하지 않은 이유는 일반적으로 디바이스 정보는 초기에만 설정을 해주고 나머지는 주로 읽기 때문에 이러한 구성을 선택하였다).

 기존의 수많은 STL 관련 서적들에서는 주로 숫자로 된 원소만 정렬하기 때문에 과연 실무에서 응용이 될지 의문이 들었었는데, 프로젝트를 하다 보니 응용을 하게 되어 다시 정리하게 되었다.


디바이스 리스트의 중복 검사

 일반적인 방법은 디바이스 정보중에 구분이 가능한 유니크(unique)한 요소로 비교하여 중복이 될 경우에는 바로 삭제하면 좋겠지만, vector에서 비교 도중에 삭제할 경우 index가 변경되는등 예상지 못하는 상황이 발생된다(그리고 코드도 복잡해진다).


 때문에 안전한 방법 생각한것은 다음과 같다.


1. 중복 검사중에는 중복으로 판된된 vector의 index만 따로 뽑아서 다른 vector에 저장을 해놓는다.


 이부분은 상황에 따라서 로직을 만들면 된다. 여기서는 잘 알려진 방법인 버블 정렬 하는 방식으로 비교하되 같은지 여부를 체크한다. 이 경우 2개의 중복이 있을 경우 문제가 안되지만, 3개 이상의 중복 원소가 있을 경우에는 문제가 생긴다. 때문에 이를 보완하기 위해서 2, 3단계들을 추가로 진행하는 것이다.


2. 중복 index가 있는 vector는 int같은 숫자 원소를 갖고 있기 때문에 (대부분 STL 교재의 예제에 있는)일반적으로 중복 검사 알고리즘으로 제거를 한다.


3. 중복 검사가 끝난 index들을 재 정렬을 한다.


4. 3에서 정렬한 vector의 index를 읽어서 제거를 한다. 이때 index가 큰 순서대로(배열의 뒤에서 부터) 제거를 한다.


 vector가 뒤에서 줄어들기 때문에 index가 바뀌는 일도 없고, 데이터 삭제시 이동되는 위치가 다르기 때문에 연산량도 줄어들게 된다.


STL vector 중복 제거

#include <vector>
#include <algorithm>
#include <string>

using namespace std;

struct deviceinfo
{
    string hostname;
    // 기타 요소
};

vector<int> checkOverlap(const vector<deviceinfo> &devVec)
{
    // 중복되는 원소가 보이면, 해당 index를 indexVec에 넣어주는 알고리즘을 구현한다.
    // 여기서는 devVec의 구조체 안에 hostname이 string을 비교한다고 가정한다.
    vector<int> indexVec;
    auto it = devVec.begin();    // auto는 C++11이상에서 사용
    for(int i=0; i<devVec.size(); ++i)
    {
        for(int j=i+1; j<devVec.size(); ++j)
        {
            if(0 == it[i].hostname.compare(it[j].hostname))
                indexVec.push_back(j);
        }
    }
    return indexVec;
}

void rmOverlap(vector<deviceinfo> &devVec)
{
    vector<int> indexVec = checkOverlap(devVec);

    // index중에서 중복되는 부분을 제거
    sort(indexVec.begin(), indexVec.end(), less<int>() );
    vector<int>::iterator pos;
    pos = unique(indexVec.begin(), indexVec.end() );
    indexVec.erase(pos, indexVec.end() );

    // 중복이 제거된 index를 내림차순으로 정렬
    sort(indexVec.begin(), indexVec.end(), less<int>() );
    // 디바이스 vector에서 중복 index부분을 제거
    pos = indexVec.begin();
    for(; pos != indexVec.end(); ++pos)
    {
        devVec.erase(devVec.begin() + (*pos));
    }
}

일반적으로 알려있는 부분은 이미 다른 사람(과 교재)에서 많이 검중이 되었기 때문에 이를 응용할 경우 비교적 안전하다. 중간에 삭제 삽입이 쉬운 리스트로 중복 검사를 한뒤에 vector로 옮겨서 사용하는 방법도 방법중 하나가 된다.


참고자료

블로그: 중복제거에 대해 간략히 나옴(설명은 없음)


추가수정(2017.6.7)

반응형
반응형

C, C++ : 운영체제를 구분할 수 있는 매크로변수

알게된 배경

 규모가 큰 프로젝트의 경우 운영체제별로 빌드되는 파일이 달라야 하기 때문에 이를 구분하기 위해서 매크로 변수를 정의하여 구분을 하고 있다.


원리

 컴파일러가 컴파일을 하기 전에 매크로를 먼저 실행을 하는데, 이 때 각 컴파일러는 환경에 대한 매크로변수가 정의 되어 있다. 이 매크로변수의 존재 유무를 가지고 운영체제를 판단하는 것이다. 단, 주의 할 점은 컴파일러자신이 있는 운영체제가 반영된 것이 때문에 윈도우에서 빌드한것은 윈도우에서 실행되고 리눅스에서 빌드된것은 리눅스에서 실행된다. 대신 소스코드만 같은 파일을 사용할 수 있다는 점이다.(그리고 이를 핑계로 고용주에게 운영체제 사달라고 하겠지..)

 실제로 규모가 큰 프로젝트는 C보다는 C++에서 많이 진행되므로 실제 사용하는 경우는 C++에서 사용될 것이다.


매크로 변수들

// windows
// 32 bit, 64 bit
#ifdef _WIN32
#endif
// only 64 bit
#ifdef _WIN64
#endif

// unix
#ifdef unix
#endif
#ifdef __unix
#endif
#ifdef __unix__
#endif

// Mac OS X
#ifdef __APPLE__
#endif
#ifdef __MACH__
#endif

// Linux
#ifdef __linux__
#endif
#ifdef linux
#endif
#ifdef __linux
#endif

// FreeBSD
#ifdef __FreeBSD__
#endif


참고자료

스택오버플로워 답변들 중


반응형

'C++' 카테고리의 다른 글

gcc C++ : 리눅스 라이브러리 만들기 입문  (0) 2017.06.12
STL C++ : vector 중복원소 제거  (0) 2017.04.28
STL C++ : string을 이용한 뒷단어 검사  (0) 2017.04.24
C++ : 네임스페이스  (0) 2017.04.21
표준 레퍼런스  (0) 2017.02.18
반응형

STL C++ : string을 이용한 뒷단어 검사

정리한 배경

 문자열 처리에 대해서는 C++외에 다른 프로그래밍 언어에서도 거의 비슷한 기능들을 지원하며, 동시에 문자열 처리를 잘하는 사람이 보통 프로그래밍도 잘한다는 말도 있다. 또한 매번 필요할때 마다 손코딩을 하는 것보다는 미리 작성해놓고 보기 위함도 있다(근데 막상 보면 간단하다).


소스코드

// Utils.h
#pragma once

#include <string>

bool isHasBackword(const std::string str, const std::string backword);

// Utils.cpp
#include "Utils.h"

using namespace std;
bool isHasBackword(const string str, const string backword)
{
    string strBack(str.c_str() + (str.size() - backword.size()) );
    return strBack == backword;
}


 C 를 쓰다가 C++의 STL로 코드를 적고 보니 역시 C++이 C보다 편한 장치가 많다는 것을 다시 느껴진다.

반응형

+ Recent posts