CppSnippets

UserPreferences

serious-code.net

RecentChanges

기술자료

링크

TitleIndex

블로그

문자열

문자열 조인&스플릿
문자열 좌우의 공백을 제거하기
문자열에서 find & replace 수행하기
find_first_not_of, find_last_not_of C 버전 구현

컨테이너/알고리즘

문자열을 키로 쓰는 map, set 성능 향상시키기
map/multimap -> vector/list 변환
포인터 컬렉션을 횡단하며 객체 삭제하기
객체의 리스트를 횡단하면서 멤버 함수 호출하기
set_intersection 알고리즘의 대안

기타

numeric_limits<float>::min != numeric_limits<int>::min
생성자에서 가상 함수 호출하기
static_cast vs reinterpret_cast
배열 안의 아이템 갯수 알아내기
빠른 atan2
빠른 sqrt
표준 입출력 스트림 리다이렉션하기
미확정 매개 변수를 다른 함수의 인자로 다시 넘기기
미확정 매개 변수 처리
파일 로그 함수
복사 생성자 및 대입 연산자 막기
임시 변수 필요 없는 치환 매크로
소수 체크하기
2의 승수 체크하기

1 문자열

1.1 문자열 조인&스플릿

#if defined(UNICODE) || defined(_UNICODE)
    typedef std::basic_string<wchar_t> tstring;
    typedef std::wstringstream tstringstream;
#else
    typedef std::basic_string<char> tstring;
    typedef std::stringstream tstringstream;
#endif

template <typename Iterator, typename Seperator>
tstring join(const Iterator& first, const Iterator& last, Seperator seperator)
{
    tstringstream stream;
    stream.imbue(std::locale::classic());
    for (Iterator itr(first); itr != last; ++itr)
    {
        if (std::distance(itr, last) > 1)
            stream << *itr << seperator;
        else
            stream << *itr;
    }
    return stream.str();
}

template <typename Iterator, typename Selector, typename Seperator>
tstring join(const Iterator& first, const Iterator& last, Selector selector, Seperator seperator)
{
    tstringstream stream;
    stream.imbue(std::locale::classic());
    for (Iterator itr(first); itr != last; ++itr)
    {
        if (std::distance(itr, last) > 1)
            stream << selector(*itr) << seperator;
        else
            stream << selector(*itr);
    }
    return stream.str();
}

template <typename Container>
void split(const tstring& text, TCHAR seperator, Container& result)
{
    std::back_insert_iterator<Container> inserter(result);

    size_t before = 0, end = 0;
    tstring token = _T("");
    while (before < text.size() && end < text.size())
    {
        if ((end = text.find_first_of(seperator, before)) != tstring::npos)
        {
            token = text.substr(before, end - before);

            if (!token.empty())
                *inserter = token;

            before = end + 1;
        }
        else
        {
            token = text.substr(before, text.size() - before);
            if (!token.empty()) { *inserter = token; }
            break;
        }
    }
}

template <typename Container>
void split(const tstring& text, const tstring& seperators, Container& result)
{
    std::back_insert_iterator<Container> inserter(result);

    size_t before = 0, end = 0;
    tstring token = _T("");
    while (before < text.size() && end < text.size())
    {
        if ((end = text.find_first_of(seperators, before)) != tstring::npos)
        {
            token = text.substr(before, end - before);

            if (!token.empty())
                *inserter = token;

            before = end + 1;
        }
        else
        {
            token = text.substr(before, text.size() - before);
            if (!token.empty()) { *inserter = token; }
            break;
        }
    }
}

1.2 문자열 좌우의 공백을 제거하기

std::string trim_right(const std::string& source, const std::string& whitespaces=" \t\r\n")
{
    std::string str(source);
    return str.erase(str.find_last_not_of(whitespaces) + 1);
}

std::string trim_left(const std::string& source, const std::string& whitespaces=" \t\r\n")
{
    std::string str(source);
    return str.erase(0, str.find_first_not_of(whitespaces));
}

std::string trim(const std::string& source, const std::string& whitespaces=" \t\r\n")
{
    std::string str(source);
    return trim_left(trim_right(source, whitespaces), whitespaces);
}

std::wstring trim_right(const std::wstring& source, const std::wstring& whitespaces=L" \t\r\n")
{
    std::wstring str(source);
    return str.erase(str.find_last_not_of(whitespaces) + 1);
}

std::wstring trim_left(const std::wstring& source, const std::wstring& whitespaces=L" \t\r\n")
{
    std::wstring str(source);
    return str.erase(0, str.find_first_not_of(whitespaces));
}

std::wstring trim(const std::wstring& source, const std::wstring& whitespaces=L" \t\r\n")
{
    std::wstring str(source);
    return trim_left(trim_right(source, whitespaces), whitespaces);
}

std::string trim(const std::string& str, const std::string& whitespaces=" \t\r\n")
{
    std::string result("");

    size_t begin = source.find_first_not_of(whitespaces);
    size_t end = source.find_last_not_of(whitespaces);
    if (begin != std::string::npos && end != std::string::npos)
        result = source.substr(begin, end - begin + 1);

    return result;
}

1.3 문자열에서 find & replace 수행하기

/// \brief 주어진 문자열 내에 존재하는 문자열을 다른 문자열로 치환한다.
/// \param text 원본 문자열
/// \param find_token 찾고자 하는 문자열
/// \param replace_token 치환하고자 하는 문자열
void replace(std::string& text, const std::string& find_token, const std::string& replace_token)
{
    size_t i = 0;
    while ((i = text.find(find_token)) != string::npos)
        text.replace(i, find_token.size(), replace_token);
}

/// \brief 문장 내부에 연속적인 대상 문자를 하나로 만든다.
///
/// 즉 target을 ' '로 준 경우, 두 개 이상의 ' '를 하나의 ' '로 만든다.
/// 
/// \param text 원본 문자열
/// \param target 대상이 되는 글자
/// \return string 변환한 문자열
std::string squeeze(const std::string& text, char target)
{
    std::string str(text);
    replace(str, string(2, target), string(1, target));
    return str;
}

1.4 find_first_not_of, find_last_not_of C 버전 구현

// find_first_not_of
const char* str_spnp(const char* str, const char* charset) 
{ 
    return str == NULL ? NULL : ((*(str += strspn(str, charset)) != 0) ? str : NULL); 
}

// find_first_not_of
const wchar_t* wcs_spnp(const wchar_t* str, const wchar_t* charset) 
{ 
    return str == NULL ? NULL : ((*(str += wcsspn(str, charset)) != 0) ? str : NULL);
}

// find_last_not_of
const char* str_rspnp(const char* str, const char* charset)
{
    const char* last = NULL;
    const char* current = str;

    for (; *current; ++current)
    {
        if (!strchr(charset, *current))
            last = current;
    }

    return last;
}

// find_last_not_of
const wchar_t* wcs_rspnp(const wchar_t* str, const wchar_t* charset)
{
    const wchar_t* last = NULL;
    const wchar_t* current = str;

    for (; *current; ++current)
    {
        if (!wcschr(charset, *current))
            last = current;
    }

    return last;
}

#if defined(UNICODE) || defined(_UNICODE)
    #define tstrspnp(str, charset)  wcs_spnp(str, charset)
    #define tstrrspnp(str, charset) wcs_rspnp(str, charset)
#else
    #define tstrspnp(str, charset)  str_spnp(str, charset)
    #define tstrrspnp(str, charset) str_rspnp(str, charset)
#endif

2 컨테이너/알고리즘

2.1 문자열을 키로 쓰는 map, set 성능 향상시키기

////////////////////////////////////////////////////////////////////////////////
/// \class cStringKey
/// \brief STL 컨테이너를 위한 문자열 키
////////////////////////////////////////////////////////////////////////////////

class cStringKey
{
private:
    enum
    {
        BYTE_SIZE = 32,
    };

    char m_Text[BYTE_SIZE]; ///< 문자열


public:
    /// \brief 생성자
    cStringKey()
    {
        memset(m_Text, 0, sizeof(m_Text));
    }

    /// \brief 생성자
    cStringKey(const char* text)
    {
        memset(m_Text, 0, sizeof(m_Text));
        memcpy_s(m_Text, sizeof(m_Text), text, std::min(sizeof(m_Text), strlen(text)));
    }

    /// \brief 생성자
    cStringKey(const std::string& text)
    {
        memset(m_Text, 0, sizeof(m_Text));
        memcpy_s(m_Text, sizeof(m_Text), text.c_str(), std::min(sizeof(m_Text), text.size()));
    }

    /// \brief 복사 생성자
    cStringKey(const cStringKey& rhs)
    {
        memcpy_s(m_Text, sizeof(m_Text), rhs.m_Text, sizeof(m_Text));
    }


public:
    /// \brief 대입 연산자
    inline const cStringKey& operator = (const cStringKey& rhs)
    {
        if (this != &rhs)
            memcpy_s(m_Text, sizeof(m_Text), rhs.m_Text, sizeof(m_Text));

        return *this;
    }

    /// \brief 비교 연산자
    ///
    /// 이 함수는 약간 유의해야 하는데, 속도를 위해 루프를 풀어버렸기 때문이다.
    /// 클래스의 크기가 변경되면, 이 함수도 같이 변경해줘야 한다.
    inline bool operator < (const cStringKey& rhs) const
    {
        const int* buf1 = reinterpret_cast<const int*>(this);
        const int* buf2 = reinterpret_cast<const int*>(&rhs);

        if (*buf1 != *buf2) return *buf1 < *buf2; // 0-3

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 4-7

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 8-11

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 12-15

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 16-19

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 20-23

        ++buf1; ++buf2;
        if (*buf1 != *buf2) return *buf1 < *buf2; // 24-27

        ++buf1; ++buf2;
        return *buf1 < *buf2; // 28-31
    }
};

typedef std::map<std::string, std::string> OLD_MAP;
typedef std::map<cStringKey, std::string> NEW_MAP;

OLD_MAP oldMap;
NEW_MAP newMap;

for (int i=0; i<1000; ++i)
{
    std::string key = generic::to_string(rand() % 1000, 4);
    std::string value = generic::to_string(rand() % 1000, 4);
    oldMap.insert(OLD_MAP::value_type(key, value));
    newMap.insert(NEW_MAP::value_type(key, value));
}

DWORD begin = 0, oldTime = 0, newTime = 0;
int repetition = 200000;

begin = timeGetTime();
for (int i=0; i<repetition; ++i)
{
    oldMap.find(generic::to_string(rand() % 1000, 4));
}
oldTime = timeGetTime() - begin;

begin = timeGetTime();
for (int i=0; i<repetition; ++i)
{
    newMap.find(generic::to_string(rand() % 1000, 4));
}
newTime = timeGetTime() - begin;

std::cout << "OLD: " << oldTime << std::endl;
std::cout << "NEW: " << newTime << std::endl;

2.2 map/multimap -> vector/list 변환

template <typename I, typename C>
inline void make_sequence(const I& first, const I& last, C& container)
{
    std::back_insert_iterator<C> inserter(container);
    for (I itr(first); itr != last; ++itr, ++inserter)
        *inserter = itr->second;
}

std::map<int, int> myMap;
myMap[0] = 0;
myMap[1] = 1;
myMap[2] = 2
myMap[3] = 3

std::vector<int> myVector;
make_sequence(myMap.begin(), myMap.end(), myVector);

template <typename I, typename C>
inline void make_sorted_sequence(const I& first, const I& last, C& container)
{
    std::back_insert_iterator<C> inserter(container);
    for (I itr(first); itr != last; ++itr, ++inserter)
        *inserter = itr->second;

    std::sort(container.begin(), container.end());
}

template <typename I, typename C, typename P>
inline void make_sorted_sequence(const I& first, const I& last, C& container, P comp)
{
    std::back_insert_iterator<C> inserter(container);
    for (I itr(first); itr != last; ++itr, ++inserter)
        *inserter = itr->second;

    std::sort(container.begin(), container.end(), comp);
}

2.3 포인터 컬렉션을 횡단하며 객체 삭제하기

순차형(sequential) 컬렉션

typedef std::list<OBJECT*> OBJECTS;
OBJECTS objects;
...
for (OBJECTS::iterator itr(objects.begin()); itr != object.end(); )
{
    OBJECT* object = *itr;

    if (should_delete(object))
    {
        itr = objects.erase(itr);
        delete object;
    }
    else itr++;
}

연관형(associative) 컬렉션

typedef std::map<int, OBJECT*> OBJECTS;
OBJECTS objects;
...
for (OBJECTS::iterator itr(objects.begin()); itr != object.end(); )
{
    OBJECT* object = itr->second;

    if (should_delete(object))
    {
        objects.erase(itr++);
        delete object;
    }
    else itr++;
}

struct YES {};
struct NO {};

template <typename T>
struct is_ptr { enum { result = false }; typedef NO Result; };

template <typename T>
struct is_ptr<T*> { enum { result = true }; typedef YES Result; };

template <typename T>
struct is_ptr<T* const> { enum { result = true }; typedef YES Result; };

template <typename T>
struct is_ptr<T* volatile> { enum { result = true }; typedef YES Result; };

template <typename T>
struct is_ptr<T* const volatile> { enum { result = true }; typedef YES Result; };

template <typename T>
class is_pair
{
private:
    template <typename U> 
    struct is_pair_imp 
    {
        enum { value = false }; 
        typedef NO Result;
    };

    template <typename U, typename V>
    struct is_pair_imp < std::pair<U, V> >
    {
        enum { value = true };
        typedef YES Result;
    };

public:
    enum { value = is_pair_imp<T>::value };
    typedef typename is_pair_imp<T>::Result Result;
};

template <typename IS_POINTER>
struct do_delete {};

template <>
struct do_delete<YES>
{
    template <typename U>
    void operator()(U param) { delete param; }
};

template <>
struct do_delete<NO>
{
    template <typename U>
    void operator()(U param) {}
};
        
template <typename IS_ASSOCIATION>
struct delete_if_imp {};

template <>
struct delete_if_imp<YES>
{
    template <typename CONTAINER, typename PREDICATE>
    void operator()(CONTAINER& container, PREDICATE comp)
    {
        do_delete< is_ptr<CONTAINER::value_type::second_type>::Result > doDelete;
        for (CONTAINER::iterator itr(container.begin()); itr != container.end();)
        {
            if (comp(itr->second))
            {
                doDelete(itr->second);
                container.erase(itr++);
            }
            else ++itr;
        }
    }
};

template <>
struct delete_if_imp<NO>
{
    template <typename CONTAINER, typename PREDICATE>
    void operator()(CONTAINER& container, PREDICATE comp)
    {
        do_delete< is_ptr<CONTAINER::value_type>::Result > doDelete;
        for (CONTAINER::iterator itr(container.begin()); itr != container.end();)
        {
            if (comp(*itr))
            {
                doDelete(*itr);
                itr = container.erase(itr);
            }
            else ++itr;
        }
    }
};

template <typename CONTAINER, typename PREDICATE>
inline void delete_if(CONTAINER& container, PREDICATE comp)
{
    delete_if_imp< is_pair<CONTAINER::value_type>::Result > imp;
    imp(container, comp);
}

2.4 객체의 리스트를 횡단하면서 멤버 함수 호출하기

class myclass
{
public:
    void heartbeat() { ... }
    void set(int param) { ... }
};

std::list<myclass> obj_list;
std::list<myclass*> ptr_list;

for_each(obj_list.begin(), obj_list.end(), 
    mem_fun(&myclass::heartbeat));

for_each(ptr_list.begin(), ptr_list.end(), 
    mem_fun<void, myclass>(&myclass::heartbeat));

for_each(ptr_list.begin(), ptr_list.end(), 
    bind2nd(mem_fun1<void, myclass, int>(&myclass::heartbeat), 99));

2.5 set_intersection 알고리즘의 대안

template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_intersection(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_intersection(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp
   );

정렬된 두 개의 컨테이너에서 교집합을 구하는 알고리즘

VisualCpp

template <typename T>
void intersection(const T& c1, const T& c2, T& u)
{
    T::const_iterator first1(c1.begin());
    T::const_iterator last1(c1.end());
    T::const_iterator first2(c2.begin());
    T::const_iterator last2(c2.end());

    for (; first1 != last1 && first2 != last2; )
    {
        if (*first1 < *first2)
            ++first1;
        else if (*first2 < *first1)
            ++first2;
        else
            u.insert(*first1++), ++first2;
    }
}

template <typename T>
bool has_intersection(const T& c1, const T& c2)
{
    T::const_iterator first1(c1.begin());
    T::const_iterator last1(c1.end());
    T::const_iterator first2(c2.begin());
    T::const_iterator last2(c2.end());

    for (; first1 != last1 && first2 != last2; )
    {
        if (*first1 < *first2)
            ++first1;
        else if (*first2 < *first1)
            ++first2;
        else
            return true;
    }

    return false;
}

3 기타

3.1 numeric_limits<float>::min != numeric_limits<int>::min

std::numeric_limits<int>::min() = -2147483648
std::numeric_limits<int>::max() = 2147483647
std::numeric_limits<float>::min() = 1.175494E-38
std::numeric_limits<float>::max() = 3.402823E+38

-std::numeric_limits<float>::max()

3.2 생성자에서 가상 함수 호출하기

CppDebuggingTips

#include <stdio.h>

class base
{
public: 
    base() { initialize(); };

protected: 
    virtual void virtual_function() 
    { 
        printf("callling base class virtual function\n");  
    };

    base(int i) {}; 

    void initialize(){ virtual_function(); init_more(); }; 
    void init_more() { printf("some more base specific work here\n"); }; 
}; 

class derived : public base 
{ 
public: 
    derived() : base(1) { initialize(); }; 

protected: 
    virtual void virtual_function() 
    { 
        printf("calling derived class virtual function\n"); 
    };

    void initialize() { base::initialize(); init_more(); }; 
    void init_more(){ printf("some more derived specific work here\n"); }; 
}; 

int main()
{
    base abc; 
    printf("=========\n"); 
    derived def;
    return 0;
}

callling base class virtual function 
some more base specific work here 
========= 
calling derived class virtual function 
some more base specific work here 
some more derived specific work here

3.3 static_cast vs reinterpret_cast

Operation: static_cast

Operation: reinterpret_cast

3.4 배열 안의 아이템 갯수 알아내기

How Would You Get the Count of an Array in C++?

3.5 빠른 atan2

#include <math.h>
#include <assert.h>

#define ASSERTS_ENABLED 1

#ifndef PI
    #define PI 3.14159265358979323846
#endif

static inline float interp( float r, float a, float b )
{
    return r*(b-a) + a;
}

enum {NUM_ATAN_ENTRIES  =1000};

static float pATanTBL[NUM_ATAN_ENTRIES+1];

static void createTrigTBLS(void)
{
    unsigned int i;

    for(i=0; i < NUM_ATAN_ENTRIES+1; i++)
    {
        float y = 10.f;
        float x = y / i * NUM_ATAN_ENTRIES;
        pATanTBL[i] = (float)atan2(y, x);
    }
}

inline float CheckReturnA(double Angle, double x) 
{
#ifdef ASSERTS_ENABLED
    static double maxerr = 0;
    double err = ::fabs( Angle - x );
    if ( err>maxerr ) maxerr = err;
#endif
/*
const double ERROR_VALUE = 1e-4;
    if (Angle < (x) - ERROR_VALUE || Angle > (x) + ERROR_VALUE)
        throw &quot;Incompatible values found at CheckReturn()&quot;; 
    return float(x);
*/
    return x;
}

#define CheckReturn(x) { CheckReturnA(Angle,(x)); return float(x); }

static double calcAngle( float x, float y )
{
    float di = (y/x)*NUM_ATAN_ENTRIES;
    unsigned int i = int( di );
    if ( i>=NUM_ATAN_ENTRIES )
        return ::atan2( y, x );
    return interp( di-i, pATanTBL[i], pATanTBL[i+1] );
}

float MMATan2(float y, float x)
{
#if ASSERTS_ENABLED
    float Angle = (float)atan2(y,x);
#endif

    if(y == 0.f) // the line is horizontal
    {
        if( x > 0.f) // towards the right
        {
            // the angle is 0
            CheckReturn(0.f);
        }               
        // toward the left
        //CheckReturn(PI);
        return (PI);
    }

    // we now know that y is not 0 check x
    if(x == 0.f) // the line is vertical
    {       
        if( y > 0.f) 
        {
            CheckReturn(PI/2.f);
        }
        CheckReturn(-PI/2.f);
    }

    // from here on we know that niether x nor y is 0
    if( x > 0.f) 
    {
        // we are in quadrant 1 or 4
        if (y > 0.f) 
        {
            // we are in quadrant 1
            // now figure out which side of the 45 degree line
            if(x > y) 
            {
                CheckReturn(calcAngle(x,y));
            }
            CheckReturn((PI/2.f) - calcAngle(y,x));
        }
        // we are in quadrant 4
        y = -y;
        // now figure out which side of the 45 degree line
        if( x > y) 
        {
            CheckReturn(-calcAngle(x,y));
        }
        CheckReturn(-(PI/2.f) + calcAngle(y,x));
    }

    // we are in quadrant 2 or 3
    x = -x; // flip x so we can use it as a positive
    if ( y > 0) 
    {
        // we are in quadrant 2
        // now figure out which side of the 45 degree line
        if ( x > y) 
        {
            CheckReturn(PI - calcAngle(x,y));
        }
        CheckReturn(PI/2.f + calcAngle(y,x));
    }
    // we are in quadrant 3
    y = -y; // flip y so we can use it as a positve
    
    // now figure out which side of the 45 degree line
    if( x > y) 
    {
        CheckReturn(-PI + calcAngle(x,y));
    }

    CheckReturn(-(PI/2.f) - calcAngle(y,x));
}

3.6 빠른 sqrt

http://www.gamedev.net/community/forums/topic.asp?topic_id=139956

float InvSqrt(float x)
{
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

float FastSqrt(float x) { return 1.0f / InvSqrt(x); }

FAST INVERSE SQUARE ROOT (PDF)

3.7 표준 입출력 스트림 리다이렉션하기

FILE *fpin, *fpout, *fperr;
bool in_redirected, out_redirected, err_redirected;

inredirected = outredirected = errredirected = false;

if ((fpin = freopen("stdin.txt","rt",stdin)) != NULL)
    in_redirected = true;

if ((fpout = freopen("stout.txt","wt",stdout)) != NULL)
    out_redirected = true;

if ((fperr = freopen("stderr.txt","wt",stderr)) != NULL)
    err_redirected = true;

// do stuff with console redirected to files

if (in_redirected) freopen("CON","rt",stdin);
if (out_redirected) freopen("CON","wt",stdout);
if (err_redirected) freopen("CON","wt",stderr);

3.8 미확정 매개 변수를 다른 함수의 인자로 다시 넘기기

#include <stdio.h>
#include <stdarg.h>
#include <conio.h>

void inner(const char* fmt, va_list args)
{
    vfprintf(stdout, fmt, args);
    vfprintf(stderr, fmt, args);
}

void outer(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    inner(fmt, args);
    va_end(args);
}

int main()
{
    outer("%d%s\n", 999, "gogogo");
    _getch();
    return 0;
}

Special Issues with Varargs Functions

3.9 미확정 매개 변수 처리

void my_sprintf(char* output, size_t length, char* fmt, ...) 
{ 
    va_list argptr;

    int precision  = 10;  // 유효 자릿수는 기본 10자리
    int decimal    = 0;   // 소숫점 위치
    int nagative   = 0;   // 음수 여부
    char temp[256] = {0}; // 임시 버퍼

    va_start(argptr, fmt);
    for (char* cur=fmt; *cur; ++cur)
    {
        memset(temp, 0, sizeof(temp));
        if (*cur != '%')
        {
            sprintf_s(temp, sizeof(temp), "%c", *cur);
            strcat_s(output, length, temp);
            continue;
        }

        switch (*(++cur))
        {
        case 'd':
            _itoa_s(va_arg(argptr, long), temp, sizeof(temp), 10);
            strcat_s(output, length, temp);
            break;
        case 'f':
            _ecvt_s(temp, sizeof(temp), va_arg(argptr, double), precision, &decimal, &nagative);
            memmove(temp + decimal + 1, temp + decimal, strlen(temp) - decimal + 1);
            temp[decimal] = '.';
            if (nagative)
            {
                memmove(temp + 1, temp, strlen(temp) + 1);
                temp[0] = '-';
            }
            strcat_s(output, length, temp);
            break;
        case 's':
            strcat_s(output, length, va_arg(argptr, char*));
            break;
        default:
            strcat_s(output, length, cur);
            break;
        }
    }
    va_end(argptr);
}

3.10 파일 로그 함수

/// \brief 파일에다 로그하기
/// \param szFilename 로그를 출력하고자 하는 파일 이름. NULL일 경우,
/// 실행 파일의 이름에다 ".log"를 붙여서 출력 파일로 사용한다.
/// \param fmt 로그 포맷
/// \param ... 로그 내용
void filelog(const char* szFilename, char* fmt, ...)
{
    ofstream file;

    if (szFilename != NULL) 
    { 
        file.open(szFilename, ios::out | ios::app); 
    }
    else
    {
        char szModulePathname[_MAX_PATH*2] = {0,};
        ::GetModuleFileName(NULL, szModulePathname, _MAX_PATH);
        ::strcat(szModulePathname, ".log");
        file.open(szModulePathname, ios::out | ios::app);
    }

    if (file.is_open())
    {
        time_t now = time(0);
        file << ctime(&now) << " : ";

        va_list valist;
        va_start(valist, fmt);

        char stack_buf[512] = {0,};
        int nchars = _vsnprintf(stack_buf, sizeof(stack_buf)-1, fmt, valist);
        if (0 < nchars || nchars < sizeof(stack_buf))
        {
            stack_buf[sizeof(stack_buf)-1] = 0;
            file << stack_buf << endl;
        }
        else
        {
            int buflen = sizeof(stack_buf);
            char* heap_buf = NULL;

            do {
                buflen = buflen * 2;
                heap_buf = reinterpret_cast<char*>(::realloc(heap_buf, buflen));
                memset(heap_buf, 0, buflen);
                nchars = _vsnprintf(heap_buf, buflen, fmt, valist);
            } while (nchars < 0 || nchars >= buflen);

            heap_buf[buflen-1] = 0;
            file << heap_buf << endl;
            ::free(heap_buf);
        }

        va_end(valist);
    }
}

3.11 복사 생성자 및 대입 연산자 막기

BoostLibrary

소스

#pragma once
      
//////////////////////////////////////////////////////////////////////////////
/// \class Noncopyable
/// \brief 복사 생성자나 대입 연산자가 사용되면 곤란한 클래스들은 이 클래스를 
/// private으로 상속하면, 컴파일 때 에러가 발생하면서 복사 생성자나 대입 
/// 연산자를 사용할 수 없다고 알려준다.
//////////////////////////////////////////////////////////////////////////////

class Noncopyable
{
protected:
    Noncopyable() {}
    ~Noncopyable() {}

private:
    Noncopyable(const Noncopyable&);
    const Noncopyable& operator = (const Noncopyable&);
};

#ifdef _MSC_VER
    // 복사 생성자를 생성하지 못했습니다.
    #pragma warning(disable:4511)

    // 컴파일러에서 주어진 클래스에 대한 대입 연산자를 생성할 수 없습니다.
    #pragma warning(disable:4512)
#endif

/// 사정상 Noncopyable을 바로 상속받지 못하는 클래스에서, 
/// 복사 생성자 및 연산자를 막기 위한 매크로
#define DECLARE_NONCOPYABLE(NAME) private: \
    NAME(const NAME&) {} \
    NAME& operator = (const NAME&) { return *this; }

사용예

class MustNotCopy1 : private Noncopyable 
{ 
... 
};

class MustNotCopy2 : list<SomeThing> 
{
DECLARE_NONCOPYABLE(MustNotCopy2)
...
}

3.12 임시 변수 필요 없는 치환 매크로

#define SWAP(A,B)  { (A) ^= (B) ^= (A) ^= (B); }

3.13 소수 체크하기

bool is_prime(int n)
{
    if (n == 2) return true;
    if (n == 1 || n % 2 == 0) return false;

    int limit = n / 2;
    for (int k = 3; k <= limit; k += 2)
        if (n % k == 0)
            return false;

    return true;
}

3.14 2의 승수 체크하기

bool isPowerOfTwo(int x)
{
    return (!(x & (x-1)));
}

see also Cpp, STL

CategoryLanguage

FindPage by browsing, title search , text search or an index
Or try one of these actions: AttachFile, DeletePage, LikePages, LocalSiteMap, RenamePage, SpellCheck

SeriousMoin v1 (koMoinMoin 1.0a4 Modified)