Write and read unicode test using wfstream

fstream을 이용하여 유니코드 문자를 저장하려 시도하였다. 쉽게 "w"만을 붙여서 wofstream을 이용하고 wchar_t 또는 wstring을 출력만 하면 될 줄 알았으나 기대대로 동작을 하지 않았다. 문자열 인코딩 문제등등 여러가지 복잡한 문제가 있었다. 여러 정보를 취합해 나중에 도움이 될 수 있도록 코드를 남겼다.

class Unicodecvt : public std::codecvt<wchar_t, char, mbstate_t>
{
protected:
 virtual bool do_always_noconv() const
 {
  return true;
 }
};

// Writting
std::wofstream fOut(L"D:\\test.txt", std::ios_base::binary);
fOut.imbue(std::locale(std::locale(""), ::new Unicodecvt));
fOut << wchar_t(0xFEFF);  // write BOM (UTF-16LE)
fOut << L"유니코드 출력 테스트: " << 12345 << std::endl;
fOut.close();

// Reading
std::wifstream fIn(L"D:\\test.txt", std::ios_base::binary);
fIn.imbue(std::locale(std::locale(""), ::new Unicodecvt));
if ( fIn.is_open() )
{
 fIn.seekg(2); // Skip BOM
 while ( !fIn.eof() )
 {
  wchar_t wszBuf[1024] = { 0, };
  fIn.getline( (wchar_t*)wszBuf, _countof(wszBuf));
 }
}
fIn.close();

참조 문서
https://golbenge.wordpress.com/2009/12/24/stl을-이용한-unicode-텍스트-파일-출력 http://saneh.tistory.com/entry/STL-유니코드-저장읽기

C++ 문자열 비교 속도 테스트

string strSrc = "Test string...";

strSrc.compare("Test strinG...")  vs _stricmp( strSrc.c_str(), "Test strinG...")

문자열 비교 테스트를 하는데 위 코드가 월등하게 빠를것으로 예상하고 테스트 했는데 아래 코드가 더 빠르다.

아래쪽은 대소문자를 무시하는 비교라 연산이 더 들어가는데 어떻게 더 빠른건가 했더니... Debug 모드이다.

Release 모드에서는 위쪽 코드를 백만번 수행해도 시간측정이 되지 않는다.(예상대로 훨씬 빨랐다.)

STL 코드에 디버그 코드가 상대적으로 많이 포함되어 있는 듯 하다.

추가로 아래의 대소문자를 구분한 코드도 비교해 보았다.

strcmp( strSrc.c_str(), "Test strinG...")

결과는 위 코드는 string의 compare 함수와 크게 차이가 나지 않았다.

보다 나은 성능을 고려할때에는 문자열 비교 할 때 대 소문자를 구분 하거나 미리 대문자든 소문자든 바꾸어 놓은 후 비교를 해야겠다.

<

Original Post : http://neodreamer-dev.tistory.com/689

vector 복사하기

// copy 알고리즘을 이용한 복사
vDst.resize( (int)(vSrc.size()) );
std::copy( vSrc.begin(), vSrc.end(), vDst.begin() );
std::copy( vSrc.begin() + 2, vSrc.begin() + 5, vDst.begin() );

// assign 을 이용한 복사
vDst.clear();
vDst.assign( vSrc.begin(), vSrc.end() ); // 전체 복사
vDst.assign( vSrc.begin() + 1, vSrc.begin() + 4 );

Original Post : http://neodreamer-dev.tistory.com/331

map 에서의 원소 추가 및 접근 ( insert, find, operator[] )

stl 의 컨테이너 중 하나인 map 에는 원소의 추가와 접근 할 때 operator 에 의한 방법과 함수에 의한 방법이 있다.

이 두 가지 방법에는 차이가 있다.



존재하지 않는 키에 대한 접근이 일어날 경우 operator[]는 빈 객체를 만들어 생성여 반환을 하고 find 함수는 맵의 마지막 포인터를 반환한다.

operator[] 에 의한 키의 접근시 존재가 확실하지 않는 경우라면 예기치 않은 원소를 만들 수 있다.

std::map< int, std::string > alias;
    // alias    [0]()

// operator[]에 의한 데이터 추가
alias[ 1 ] = "cat";
    // alias    [1]((1,"cat"))
alias[ 2 ] = "dog";
    // alias    [2]((1,"cat"),(2,"dog"))

// insert 함수에 의한 추가
alias.insert( make_pair( 3, "bird" ) );
    // alias    [3]((1,"cat"),(2,"dog"),(3,"bird"))
alias.insert( make_pair( 4, "flog" ) );
    // alias    [4]((1,"cat"),(2,"dog"),(3,"bird"),(4,"flog"))

// operator[]에 의한 데이터 접근
std::string animal;
animal = alias[ 3 ];
    // animal    "bird"

animal = alias[ 5 ];
    // alias    [5]((1,"cat"),(2,"dog"),(3,"bird"),(4,"flog"),(5,""))
    // animal    ""

// find 함수에 의한 접근
std::map< int, std::string >::iterator itFind = alias.find( 2 );
    // itFind    (2,"dog")
if ( itFind != alias.end() )
{
    animal = itFind->second;
        // animal    "dog"
}

itFind = alias.find( 6 );
    // itFind    (-842150451,<Bad Ptr>)
    // alias    [5]((1,"cat"),(2,"dog"),(3,"bird"),(4,"flog"),(5,""))
if ( itFind != alias.end() )
{
    animal = itFind->second;
}

Original Post : http://neodreamer-dev.tistory.com/328

STL bitset 사용 예

C++ STL 의 bitset 을 사용한 예를 기록삼아 정리해 보았다.

#include <string>
#include <bitset>
using namespace std;

// bitset 선언
bitset< 8 > bit;
//bit    [8](0,0,0,0,0,0,0,0)    std::bitset<8>


// 전체 비트 세트
bit.set();
//bit    [8](1,1,1,1,1,1,1,1)    std::bitset<8>


// 전체 비트 리셋
bit.reset();
//bit    [8](0,0,0,0,0,0,0,0)    std::bitset<8>


// 할당 된 비트 수
int bitsize = (int)bit.size();
//bitsize    8


// 세트 된 비트 존재 여부 감사
bool bAny = bit.any();
//bAny    false    bool
bool bNone = bit.none();
//bNone    true    bool


// 첫 번째, 세 번째 비트 할당
bit.set( 0, true );
//bit    [8](1,0,0,0,0,0,0,0)    std::bitset<8>
bit.set( 2, true );
//bit    [8](1,0,1,0,0,0,0,0)    std::bitset<8>


// 다섯 번째 비트 반전
bit.flip( 4 );
//bit    [8](1,0,1,0,1,0,0,0)    std::bitset<8>


// 모든 비트 반전
bit.flip();
//bit    [8](0,1,0,1,0,1,1,1)    std::bitset<8>


// 네 번째 비트 감사
bool bFlag = bit.test( 3 );
//bFlag    true    bool


// 여섯 번째 비트 감사
bFlag = bit[ 5 ];
//bFlag    true    bool


// 세트 된 비트 존재 여부 감사
bAny = bit.any();
//bAny    true    bool
bNone = bit.none();
//bNone    false    bool


// 세트 된 비트 수
int setcount = (int)bit.count();
//setcount    5    int


// 값 할당
bit = 0x01;
//bit    [8](1,0,0,0,0,0,0,0)    std::bitset<8>
bit = 0xF0;
//bit    [8](0,0,0,0,1,1,1,1)    std::bitset<8>


// 문자로 변환
string strBits = bit.to_string();
//strBits    "11110000"


// 숫자로 변환
int    nBitVal = bit.to_ulong();
//nBitVal    240

Original Post : http://neodreamer-dev.tistory.com/326

vector 원소 복사하기

vector< int > vA;
vector< int > vB;

vA.push_back( 1 );
vA.push_back( 3 );
vA.push_back( 5 );
vA.push_back( 7 );
vA.push_back( 9 );

// 모든 원소 복사
vB.resize( vA.size() ); // 복사될 크기 만큼 공간 확보
copy( vA.begin(), vA.end(), vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >


// 처음부터 3개만 복사할 경우
vB.resize( 3 ); // 복사될 크기 만큼 공간 확보
copy( vA.begin(), vA.begin() + 3, vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [3](1,3,5)    std::vector<int,std::allocator<int> >


// 두번 째 원소부터 3개를 복사할 경우
vB.resize( 3 ); // 복사될 크기 만큼 공간 확보
copy( vA.begin() + 1, vA.begin() + 4, vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [3](3,5,7)    std::vector<int,std::allocator<int> >

Original Post : http://neodreamer-dev.tistory.com/323

[STL] std::string 대소문자 바꾸기

std::string 의 문자열을 대소문자 변환이 필요해 찾아보았는데 쉽게 처리할 수 있는 방법을 찾았다.

std::transform 함와 cctype 헤더의 tolower() 와 toupper() 함수를 이용하면 쉽게 해결이 되었다.

transform 함수는 이외에도 응용할 부분이 많아보인다. container 의 각 원소에 특정을 변형을 주어
바꾸거나 다는 container에 넣을 수도 있다. transform 함수에 대해서는 좀더 공부를 해서 나중에 포스팅을 한번 해야겠다.

#include <cctype> // for toupper & tolower
#include <string>
#include <algorithm>
using namespace std;


    // 대문자로 바꾸기
    string s1 = "sample string";
    transform( s1.begin(), s1.end(), s1.begin(), toupper );
    // 결과 : s1    "SAMPLE STRING"

    // 소문자로 바꾸기
    string s2 = "HELLO";
    transform( s2.begin(), s2.end(), s2.begin(), tolower );
    // 결과 : s2    "hello"


    // 첫 문자만 대문자로 바꾸기
    string s3 = "title";
    transform( s3.begin(), s3.begin() + 1, s3.begin(), toupper );
    // 결과 : s3    "Title"

Original Post : http://neodreamer-dev.tistory.com/267

[STL] map 의 맨 마지막 원소에 접근하기 (map.end() 는 마지막 원소가 아니다!!)

vector 나 list의 경우 크기를 가져와 마지막 원소에 쉽게 접근 할 수 있지만 map의 경우 Key 에 의해 접근으로 find() 멤버함수를 이용하여 iterator를 가져와서 접근할 수 있다.

그러면 맨 마지막 값을 가져오기 위해서는 맨 마지막 iterator를 가져오기만 하면 되는데...
map 의 member 함수 중 end() 함수가 있는데 이는 맨 마지막 iterator를 가리키기 않는다. end() 함수는 맨마지막 원소를 넘어선 map의 가장 마지막을 가르킨다. 그래서 end() 함수를 활용하여 맨 마지막 원소에 접근하려면 증감연산자(--)를 이용해 한단계 앞으로 iterator를 옮겨 주면 된다. 그리고 map 에는 rbegin() 이라는 함수도 제공하는데 이는 현재 map에 있는 원소를 거꾸로 하였을때 맨 처음 원소를 가리킨다.

map< int, Data* > mpData;

// end() 의한 마지만 원소 접근
map< int, Data* >::iterator it = --mpData.end();
Data* pData = it->second;

// rbegin() 에 의한 마지막 원소 접근
map< int, Data* >::reverse_iterator it = mpData.rbegin();
Data* pData = it->second;

위의 코드중 end() 함수에 의한 접근은 위험 요소를 갖고 있다. map에 저장된 데이터가 하나도 없을 경우 에러를 발생한다. end()에 의한 접근 전에 map의 크기를 검사 하는 루틴을 포함해 주어야한다.


Original Post : http://neodreamer-dev.tistory.com/257

[STL] vector 에서 [] 과 at() 의 차이점

vector 의 원소에 접근하는 방법은 배열의 접근 방법과 갈은 [] 를 이용하는 방법과 멤버 함수인 at() 을 이용하는 방법이 있다.
이 두가지 방법의 차이점은 첨자의 범위를 체크하는지 여부와 범위를 벗어난 접근일 경우 예외 발생 여부이다.


배열 접근 기호인 [] 에의한 접근은 첨자의 범위를 체크하지 않기 때문에 범위를 벗어난 접근을 시도할 경우 예외를 발생하지 않고 에러를 발생한다.

멤버함수 at() 를 이용한 접근은 첨자의 범위를 체크하여 벗어난 접근을 시도할 경우 std::out_of_range 예외를 발생 한다.

범위내의 접근을 보장할 경우 별도의 범위 체크가 필요 없으므로 []의해 원소에 접근하며

for ( int n = 0; n < (int)vInt.size(); ++n )

{

  int a = vInt[ n ];

  :

}

그렇지 않을 경우 at() 의한 접근으로 예외를 처리해 준다.

void foo( int n )

{

    try

    {

        int a = vInt.at( n );

    }

    catch (std::out_of_range& e)

    {

        AfxMessageBox( _T("Catch the std::out_of_range") );

    }

}


Original Post : http://neodreamer-dev.tistory.com/256

[STL] remove algorithm 은 실제로 지우지 않는다.

vector 를 사용하다 특정 원소를 삭제하기 위해 algorithm 의 remove 를 이용하였다. vector 자체에는 remove 를 지원하지 않기 때문에... 하지만 결과는 예상을 빗나가 버렸다.

remove를 하면 원소는 사라지는 것 처럼 보이는데 vector의 크기는 그대로였다.
그래서 remove에 대한 정보를 찾아보았다.

remove 의 기능은 지정된 시작위치부터 끝위치까지 탐색하여 지워야하는 원소가 있을 경우 그 위치에 다음의 지우지 않을 원소를 덮어 써서 뒤쪽의 일부 영역을 무효화 한다.
그렇게 삭제(?)를 마치면 뒤쪽의 무효화 영역이 시작되는 iterator 를 반환한다.

실제로 지우기 위해서는 이 iterator 부터 마지막까지 erase 로 지워야한다. erase 할 경우 마지막까지 지우지 않고 iterator 만 지울 경우 다수의 원소를 삭제하고자 할 경우 정확하게 지워지지 않는다.

vector< int > vInt;
vector< int >::iterator it;

vInt.push_back( 2 );
vInt.push_back( 3 );
vInt.push_back( 4 );
vInt.push_back( 12 );
vInt.push_back( 15 );
vInt.push_back( 35 );
vInt.push_back( 2 );
vInt.push_back( 62 );
vInt.push_back( 24 );
vInt.push_back( 15 );
vInt.push_back( 91 );

TRACE0("\nsource : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

it = remove( vInt.begin(), vInt.end(), 15 );
TRACE0("\nremove 15 : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

//vInt.erase( it );
vInt.erase( it, vInt.end() );
TRACE0("\nerase : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

it = remove( vInt.begin(), vInt.end(), 2 );
TRACE0("\nremove 2 : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

//vInt.erase( it );
vInt.erase( it, vInt.end() );
TRACE0("\nerase : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

결과
////////////////////////////////////////////////////////////////////////////////
// remove로 받은 iterator 만을 지울 경우 : vInt.erase( it )
source :  2 3 4 12 15 35 2 62 24 15 91

remove 15 :  2 3 4 12 35 2 62 24 91 15 91
// 15 삭제시 15 두 개가 삭제되고 뒤쪽의 원소들로 앞쪽으로 덮어 씌운다.
// 마지막 두 원소는 유령처럼 살아있다. 
// 반환된 iterator 는 끝에서 두 번째 원소를 가리킨다.
erase :  2 3 4 12 35 2 62 24 91 91
// 반환받은 iterator 위치의 원소를 삭제할 경우 마지막에서 두 번째 원소만
// 삭제한다. 마지막 91은 여전히 살아있다.

remove 2 :  3 4 12 35 62 24 91 91 91 91
erase :  3 4 12 35 62 24 91 91 91

////////////////////////////////////////////////////////////////////////////////
// remove로 받을 iterator 에서 마지막까지 지울 경우 : vInt.erase( it, vInt.end() )
source :  2 3 4 12 15 35 2 62 24 15 91

remove 15 :  2 3 4 12 35 2 62 24 91 15 91
// 15 삭제시 15 두 개가 삭제되고 뒤쪽의 원소들로 앞쪽으로 덮어 씌운다.
// 마지막 두 원소는 유령처럼 살아있다. 
// 반환된 iterator 는 끝에서 두 번째 원소를 가리킨다.
erase :  2 3 4 12 35 2 62 24 91
// 반환받은 iterator 위치부터 마지막까지 삭제할 경우 원하는 결과를 얻을 수 있다.

remove 2 :  3 4 12 35 62 24 91 24 91
erase :  3 4 12 35 62 24 91

Original Post : http://neodreamer-dev.tistory.com/255

std::string 의 날짜를 CTime에 넣기

MySQL의 DATE 함수에 의해 얻어진 std::string 문자열("YYY-MM-DD")을 CTime에 넣기.

        // "1999-01-01"
        // "0123456789"
        std::string d = "1999-01-01";

        CTime time( 
            atoi( d.substr(0, 4).c_str() ), // Year
            atoi( d.substr(5, 2).c_str() ), // Month
            atoi( d.substr(8, 2).c_str() ), // Day
            0, 0, 0 /* Time */ );

Original Post : http://neodreamer-dev.tistory.com/229

매력적인 힙 메모리 관리 템플릿 클래스 auto_ptr

new로 생성한 포인터 변수는 반드시 delete로 할당된 메모리를 해제해 주어야 한다.
짧
은 코드나 중간에 실행 경로를 바꾸는 일이 없을 경우에는 처리가 비교적 쉽지만 예외사항을 처리하고 중간에 함수를 빠져나가는
경우가 있을경우 힙 영역에 할당한 메모리 해제에 대하여 신중해야한다. 이럴경우 auto_prt 을 사용하면 편리하다.

MySQL Connector/C++ 을 사용하면서 사용하게 되었는데 아주 놈이다.

사용 방법은 아래와 같다.
std::auto_ptr< 데이터 타입 > variable( 할당할 데이터 포인터 );

std::auto_ptr< int > myInt( new int(5) );

위
의 구문은 myInt 를 int 형을 가리키는 포인터이며 새로 생성한 int(5)를 가리키고 있다. 이때 생성한 new
int(5) 는 명시적으로 delete로 해제 하지 않아도 함수가 종료되는 시점에 자동으로 delete가 된다.

auto_ptr 은 기본적으로 포이터만 핸들링 할 수 있으며 포인터 배열( new int[5] )의 경우 메모리 해제에 문제가 있다. 그리고 stl 의 container 에는 사용할 수 없다.

auto_ptr 은 기본 생성자및 소멸자 외에 다음과 같은 메소드를 갖고 있다.
auto_ptr::get()
    auto_ptr이 담고 있는 데이터의 포인터를 반환

auto_ptr::operator *
    auto_ptr이 담고 있는 객체

auto_ptr::operator ->
    auto_ptr 이 담고 있는 객체의 멤버에 접근

auto_ptr::operator =
    auto_ptr 이 가리키고 있는 포이터의 소유권 이전 다른 auto_ptr에게 받아오고 넘겨준 auto_ptr 은 갖고 있던 포인터를 해제함.

auto_ptr::release()
    auto_ptr 이 가리키고 있는 포인터를 명시적으로 삭제함.

auto_ptr::reset()
    기존 포인터를 삭제하고 새로운 포인터를 할당한다

Original Post : http://neodreamer-dev.tistory.com/219

작고 빠르고 편한 Open Source XML Parser - RapidXML

XML 데이터를 분석해야 할 일이 있어서 공개 소스로 이루어진 프로젝트를 찾아 보았다.

TinyXML 과  RapidXML 을 찾았는데 둘 중 가볍고 사용하기 편한 RapidXML 을 사용하기로 하였다.

RapidXML 소스를 받으면 4개의 소스 파일로만 이루어 졌다.

rapidxml.hpp
rapidxml_iterators.hpp
rapidxml_print.hpp
rapidxml_utils.hpp

rapidxml_print 는 XML을 출력하는 기능이 포함되어 있고. rapidxml_utils 은 XML 데이터 파일을 읽어들이는 기능을 한다.

기본적인 XML 데이터 탐색을 하기위해서는 rapidxml.hpp 만 포함시키면 된다.

기본적인 사용법은 아래의 소스를 보면 한눈에 알 수 있다.

#include "rapidxml.hpp"
#include "rapidxml_utils.hpp"
using namespace rapidxml;

    // XML 문서 데이터를 저장할 변수
    vector< TCHAR > xmlData;

    // XML 파일 불러오기
    basic_ifstream<TCHAR> xmlFile( strFile );
    xmlFile.seekg(0, ios::end);
    size_t size = xmlFile.tellg();
    xmlFile.seekg(0); 

    xmlData.clear();
    xmlData.resize( size + 1);
    xmlData[size] = 0;

    xmlFile.read( &xmlData.front(), (streamsize)size );

    // XML Parsing
    xml_document< TCHAR > xmlDoc;
    xmlDoc.parse<0>( &xmlData.front() );

    TCHAR* Name;
    TCHAR* Value;
    xml_node< TCHAR >* Item;
    xml_node< TCHAR >* SubItem;
    xml_attribute< TCHAR >* Attr;

    // root 포인터
    xml_node< TCHAR >* root = xmlDoc.first_node();

    // root 하위 Node 탐색
    for ( Item = root->first_node(); Item; Item = root->next_sibling())
    {
        // Node 이름
        Name = Item->name();

        // Node 의 Attribute 탐색
        for ( Attr = Item->first_attribute(); Attr; 
            Attr = Attr->next_attribute() )
        {
            Name  = Attr->name();    // Attribute 의 이름
            Value = Attr->value();    // Attribute 의 값
        }

        for ( SubItem = Item->first_node(); SubItem; 
            SubItem = SubItem->next_sibling() )
        {
            Name  = Attr->name(); // Sub node 의 이름
        }
    }

RapidXML 홈페이지
TinyXML 홈페이지

Original Post : http://neodreamer-dev.tistory.com/204

vector를 이용한 2차원 동적 배열

STL의 컨테이너인 vector를 이용하여 2차원 동적 배열을 구현해 보았다.


vector를 이용하기 위한 포함 파일을 포함하는 방법은 개발툴 마다 조금씩 다르다.

Visual Studio 의 경우

#include <vector>

using namespace std;

C++ Builder 경우

#include <vector.h>

vector를 활용한 2차원 동적 배열은 vector 를 담는 vector 이다.
선언은 아래와 같다.

vector < vector < int > > vcArray;

선언시 주의해야할 사항은 마지막 angle bracket 2개를 붙여쓰면 쉬프트 연산자로 인식해 에러를 발생한다.

배열을 초기화 하기 위해서 원하는 ROW 만큼 반복을 하며 원하는 COL 크기의 vector를 만들어 동적 배열 vector에 넣어주면 된다. 설명보다는 코드를 보는 것이 이해가 빠를 것이다.

for ( int i = 0 ; i < ROW; ++i ) // 주어진 ROW 만큼 반복

{

    vector<int> elem; // vector 를 생성하고

    elem.resize(COL); // 원하는 COL 크기로 할당

    vcArray.push_back(elem); // 배열에 추가

}

vector 를 활용한 배열이기 때문에 위와는 다르게 각 ROW 마다 원소수(COL 의 크기)를 다르게 설정할 수도 있다. 그때 배열에 접근 할때는 인자가 범위를 벗어나지 않도록 주위를 해야한다.


이렇게 할당한 배열을 삭제할 때는 각각의 ROW 에 포함된 COL 데이터를 삭제하고 마지막으로 ROW 데이터를 삭제하면 된다.

for (int row = 0; row < (int)vcArray.size(); ++row)

    vcArray[row].clear();

vcArray.clear(); 

접근 방법은 일반 배열을 접근하듯이 하면 된다.

int temp = vcArray[1][2]; 

vcArray[1][2] = 3;


Original Post : http://neodreamer-dev.tistory.com/19