Qt Repository 와 잡담

구조체는 클래스내부에서만 사용하는 경우가 아니면 GlobalStruct클래스를 따로 만들어서 빼는게 훨씬 나은것같다.

가령

class a
{
private:
 	struct DO_SOMTHING
 	{
 	};
};

이런식으로 클래스 내부에서 한정적으로 쓰는거라면 내부 구조체로 사용하면 되지만

만약 다른곳에서 해당 구조체를 참조해야하는 상황이 벌어지면 

class globalData
{
public:

    struct DO_SOMETHING
    {
    };
};







//a class.h


#include "globalData.h"


class a
{

private:
	globalData::DO_SOMTHING d;
};


or



globalData::DO_SOMTHING d;

요런식으로 아예 그냥 공용 구조체 클래스를따로 빼버리는게 낫다.

(구조체 선언만 전문적으로 관리하는 클래스 - cpp가 없이 구조체 인터페이스 느낌이라고 생각하면 편하다.)

네임스페이스를 쓸까도 생각해봤는데 저게 더 깔끔하고 네임스페이스는 뭔가 패키지 전체를 구분짓는 듯한 뉘앙스라

저렇게 별도 클래스로 관리중.

지금 별생각없이 클래스별로 구조체만들어놨다가.. 다뜯어고치고있다 ㅡ,.ㅡ 

단순 lib와 dev가 붙은것이 있을때 dev를 설치할것.

//개인저장용

./configure -release  -no-pch -no-gbm -opengl es2 -device linux-rasp-pi3-g++ -device-option CROSS_COMPILE=~/raspi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf- -sysroot ~/raspi/sysroot -opensource -confirm-license -make libs -prefix /usr/local/qt5pi -extprefix ~/raspi/qt5pi -hostprefix ~/raspi/qt5 -no-use-gold-linker -no-compile-examples -v

./configure -release -continue -opengl es2 -device linux-rasp-pi3-g++ -device-option CROSS_COMPILE=~/raspi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf- -sysroot ~/raspi/sysroot -opensource -confirm-license -make libs -prefix /usr/local/qt5pi -extprefix ~/raspi/qt5pi -hostprefix ~/raspi/qt5 -no-use-gold-linker -no-compile-examples -nomake tests -no-xcb -no-linuxfb -no-kms -webengine-embedded-build -silent -v

//본문서는 개인 저장용이므로 다소 읽기 어려울수 있으니 양해바랍니다.

//qt raspi compile option (need tool chains)

./configure -release -no-pch -opengl es2 -device linux-rasp-pi3-g++ -device-option CROSS_COMPILE=~/raspi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf- -sysroot ~/raspi/sysroot -opensource -confirm-license -make libs -prefix /usr/local/qt5pi -extprefix ~/raspi/qt5pi -hostprefix ~/raspi/qt5 -no-use-gold-linker -v

./configure -release -continue -opengl es2 -device linux-rasp-pi3-g++ -device-option CROSS_COMPILE=~/raspi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf- -sysroot ~/raspi/sysroot -opensource -confirm-license -make libs -prefix /usr/local/qt5pi -extprefix ~/raspi/qt5pi -hostprefix ~/raspi/qt5 -no-use-gold-linker -no-compile-examples -nomake tests -no-xcb -no-linuxfb -no-kms -webengine-embedded-build -silent -v

//in platform // linux arm-gnueabi.toolchain

SET(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")

SET(GNU_MACHINE "arm-linux-gnueabi" CACHE STRING "GNU compiler triple")

SET(TOOLROOT /home/rpi/raspi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64)

SET(CMAKE_C_COMPILER ${TOOLROOT}/bin/arm-linux-gnueabihf-gcc)

SET(CMAKE_CXX_COMPILER ${TOOLROOT}/bin/arm-linux-gnueabihf-g++)

include("${CMAKE_CURRENT_LIST_DIR}/arm.toolchain.cmake")

//in build Opencv 3.x CrossCompile Lib -> Copy to usr/local/lib

cmake  -DWITH_FFMPEG=ON \

 -DWITH_JASPER=ON \

-DWITH_JPEG=ON \

-DWITH_PNG=ON \

-DWITH_TIFF=ON \

-DWITH_VFW=ON \

-DWITH_WEBP=ON \

-DWITH_TBB=ON \

-DWITH_V4L=ON \

-DWITH_OPENEXR=ON \

-DWITH_OPENGL=ON \

-DBUILD_JASPER=ON \

-DBUILD_JPEG=ON \

-DBUILD_PNG=ON \

-DBUILD_OPENEXR=ON \

-DBUILD_PACKAGE=ON \

-DBUILD_TIFF=ON \

-DBUILD_WITH_DEBUG_INFO=ON \

-DBUILD_ZLIB=ON \

-DBUILD_NEW_PYTHON_SUPPORT=ON \

-DSOFTFT=ON \

-DUSE_NEON=ON \

-DCMAKE_TOOLCHAIN_FILE=../platforms/linux/arm-gnueabi.toolchain.cmake ../

//이번 문서는 개인저장용이므로 다소 보기 어려울수도있으니 양해바랍니다.

void CameraInstance::initResolution(int width, int height, int fps)

{

    v4l2_format fmt;

    CLEAR(fmt); //memset(&fmt, 0, sizeof(fmt));

    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    fmt.fmt.pix.width  = width;

    fmt.fmt.pix.height = height;

    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;        // V4L2_PIX_FMT_MJPEG;  // V4L2_PIX_FMT_YUYV;

    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;            // V4L2_FIELD_INTERLACED;

    this->xioctl(d->mDeviceHandle, VIDIOC_S_FMT, &fmt);

bool CameraInstance::initMMAP(int handle, void*& mmapBuffer)

{

    v4l2_requestbuffers req;

    CLEAR(req);

    req.count = 1;

    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    req.memory = V4L2_MEMORY_MMAP;

    if (-1 == this->xioctl(handle, VIDIOC_REQBUFS, &req))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Requesting Buffer"), CLogWriter::LOG_TYPE_RELEASE);

        return false;

    }

    v4l2_buffer buf ;

    CLEAR(buf);

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    buf.memory = V4L2_MEMORY_MMAP;

    buf.index = 0;

    if(-1 == this->xioctl(handle, VIDIOC_QUERYBUF, &buf))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Quering Buffer"), CLogWriter::LOG_TYPE_RELEASE);

        return false;

    }

    mmapBuffer = mmap (NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, handle, buf.m.offset);

    //   printf("Length: %d\nAddress: %p\n", buf.length, buffer);

    //   printf("Image Length: %d\n", buf.bytesused);

    return true;

}

cv::Mat CameraInstance::captureQueryImage(int handle, void* mmapBuffer, int width, int height)

{

    v4l2_buffer buf;

    CLEAR(buf);

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    buf.memory = V4L2_MEMORY_MMAP;

    buf.index = 0;

    if(-1 == this->xioctl(handle, VIDIOC_QBUF, &buf))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : CaptureQuery Buffer"), CLogWriter::LOG_TYPE_RELEASE);

        return cv::Mat();

    }

    if(-1 == this->xioctl(handle, VIDIOC_STREAMON, &buf.type))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Capture Error"), CLogWriter::LOG_TYPE_RELEASE);

        return cv::Mat();

    }

    fd_set fds;

    FD_ZERO(&fds);

    FD_SET(handle, &fds);

    timeval tv;

    CLEAR(tv);

    tv.tv_sec = 2;

    int r = select(handle+1, &fds, NULL, NULL, &tv);

    if(-1 == r)

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Waiting for Frame"), CLogWriter::LOG_TYPE_RELEASE);

        return cv::Mat();

    }

    if(-1 == this->xioctl(handle, VIDIOC_DQBUF, &buf))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Retrieving Frame"), CLogWriter::LOG_TYPE_RELEASE);

        return cv::Mat();

    }

    cv::Mat matrix(height, width, CV_8UC3, (uchar*)mmapBuffer);

    cv::Mat decodedMatrix = cv::imdecode(matrix, CV_LOAD_IMAGE_UNCHANGED );

    return decodedMatrix;

}

int CameraInstance::open_device(const char* dev_name, int& fd)

{

    struct stat st;

    if(-1 == stat(dev_name, &st))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : %1 : %2, %3").arg(dev_name)

                             .arg(QString::number(errno).arg(strerror(errno))), CLogWriter::LOG_TYPE_RELEASE);

        return ERROR_LOCAL;

    }

    if(!S_ISCHR(st.st_mode))

    {

        CLogWriter::printLog(QString("[CameraInstance::] : %1 is not a valid device").arg(dev_name), CLogWriter::LOG_TYPE_RELEASE);

        return ERROR_LOCAL;

    }

    fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);

    if(-1 == fd)

    {

        CLogWriter::printLog(QString("[CameraInstance::] : Cannot open '%1' : %2 %3").arg(dev_name)

                             .arg(QString::number(errno)).arg(strerror(errno)), CLogWriter::LOG_TYPE_RELEASE);

        if(EACCES == errno)

        {

            CLogWriter::printLog(QString("[CameraInstance::] : Insufficient permissions on '%1' : %2 %3").arg(dev_name)

                                 .arg(QString::number(errno)).arg(strerror(errno)), CLogWriter::LOG_TYPE_RELEASE);

        }

        return ERROR_LOCAL;

    }

    return SUCCESS_LOCAL;

}

int CameraInstance::errnoexit(const char *s)

{

    CLogWriter::printLog(QString("[CameraInstance::] : [%1] : error %2, %3").arg(s).arg(QString::number(errno)).arg(strerror(errno)), CLogWriter::LOG_TYPE_RELEASE);

    return ERROR_LOCAL;

}

int CameraInstance::xioctl(int fd, int request, void *arg)

{

    int r;

    do r = ioctl (fd, request, arg);

    while (-1 == r && EINTR == errno);

    return r;

}

int CameraInstance::xioctl(int fd, int request, v4l2_queryctrl *arg)

{

    int r;

    do {

        r = ioctl(fd, request, arg);

    } while(-1 == r && EINTR == errno);

    return r;

}

int CameraInstance::cioctl(int fd, int request, v4l2_control *arg)

{

    int r;

    do {

        r = ioctl(fd, request, arg);

    } while(-1 == r && EINTR == errno);

    return r;

}

//헤더랑 include는 코딩맨이 처리했으니 안심하라구? (C++11 부터사용가능 auto 키워드사용)

struct CSettingIo::privateStruct

{

    QScopedPointer<QSettings> mSettings;

    QString mPath;

    QString mFileName;

};

CSettingIo::CSettingIo(QString fileName,QObject *parent) :

    QObject(parent),

    d(new privateStruct)

{

    //InI포맷으로 저장 + 로컬 설정 적용

    QString dirPath("Config");

    QDir dir;

    dir.mkpath(dirPath);

#ifdef __WIN32

    QString path = dirPath +"/"+ fileName + ".ini";

    d->mSettings.reset(new QSettings(path,QSettings::IniFormat, this));

    d->mPath = path;

    d->mFileName = fileName;

#endif

}

CSettingIo::~CSettingIo()

{

}

void CSettingIo::setConfigureData(QString mainCategory, QString key, QVariant value)

{

    QString category = QString("%1/%2").arg(mainCategory).arg(key);

    d->mSettings->setValue(category, value);

}

QVariant CSettingIo::getConfigureData(QString mainCategory, QString key)

{

    QString keyString = QString("%1/%2").arg(mainCategory).arg(key);

    auto ret = d->mSettings->value(keyString);

    return ret;

}

QString CSettingIo::getPath()

{

    return d->mPath;

}

QString CSettingIo::getFileName()

{

    return d->mFileName;

}

//기본형태

//코어수에 맞춰  병렬처리하라

#pragma omp parallel for

for(int i =0; i< size ; i++)

     copy[i] = original[i];

//합계연산

//각 코어마다 독립된 공간을 가지고 합계를 낸다음 최종적으로 합계를 연산

//그냥 일반 for명령을 사용하면 동시성 문제 발생

int sum = 0;

#pragma omp parallel for reduction(+:sum)  //여러개를 계산하고싶다면 (+: 변수, 변수, 변수 , ...) 이런식 

for(int i = 0; i < size : i++)

   sum = sum +1; // sum++는 되는지 안되는지 아직 파악못함

//2018-07-24추가 (순서대로 병렬처리)

#pragma omp parallel for ordered

    for(auto i = 0; i < end; i++)

#pragma omp ordered

        rawData.push_back(data.at(i));

위코드에서 한줄이라 {}를 생략하였으나

{}으로 Scope지정가능

#ifndef CUTIL_H

#define CUTIL_H

#include <string>
#include <vector>

#ifdef USE_QT

#include <QString>

class CUtil

{

public:

    CUtil();

    virtual ~CUtil();

    enum ENDIAN

    {

        ENDIAN_BIG,

        ENDIAN_LITTLE

    };

    //toString overRide

    static QString toString(char target);

    static QString toString(uchar target);

    static QString toString(short target);

    static QString toString(ushort target);

    static QString toString(int target);

    static QString toString(uint target);

    static QString toString(double target);

    static QString hexaToString(char target);

    static QString hexaToString(uchar target);

    static QString hexaToString(short target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static QString hexaToString(ushort target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static QString hexaToString(int target,  CUtil::ENDIAN endian = ENDIAN_BIG);

    static QString hexaToString(uint target, CUtil::ENDIAN endian = ENDIAN_BIG);

    //typecast

    static QString ucharArrayToString(uchar* str);

    static QString ucharArrayToString(uCharArrayStream& stream);

    static void messageBox(const char *str);

    static void messageBox(const uchar *str);

};

#else

class CUtil

{

public:

    CUtil();

    virtual ~CUtil();

    enum ENDIAN

    {

        ENDIAN_BIG,

        ENDIAN_LITTLE

    };

    //toString overRide

    static std::string toString(char target);

    static std::string toString(uchar target);

    static std::string toString(short target);

    static std::string toString(ushort target);

    static std::string toString(int target);

    static std::string toString(uint target);

    static std::string toString(double target);

    static std::string hexaToString(char target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static std::string hexaToString(uchar target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static std::string hexaToString(short target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static std::string hexaToString(ushort target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static std::string hexaToString(int target, CUtil::ENDIAN endian = ENDIAN_BIG);

    static std::string hexaToString(uint target, CUtil::ENDIAN endian = ENDIAN_BIG);

    //typecast

    static std::string ucharArrayToString(uchar* str);

    static std::string ucharArrayToString(uCharArrayStream& stream);

};

#endif /* USE_QT */

#endif // CUTIL_H

//네임스페이스가 있었는데 그냥 쓰는사람이 불편할까봐 빼부럿다-ㅁ-

#include "CUtil.h"

// Creater      : sp.Park by SystemDevelopment

// Description  : Public C++ 11 Util Class

// Created Date : 2017-08-17

// Modify  Date : 2017-11-07 USE_QT Macro Addtional

#ifdef USE_QT

#include <QMessageBox>

QString CUtil::toString(char target)

{

    QString retValue;

    retValue.push_back(target);

    return retValue;

}

QString CUtil::toString(uchar target)

{

    QString retValue;

    retValue.push_back(target);

    return retValue;

}

QString CUtil::toString(short target)

{

    QString retValue;

    retValue = QString::number(target);

    return retValue;

}

QString CUtil::toString(ushort target)

{

    QString retValue;

    retValue = QString::number(target);

    return retValue;

}

QString CUtil::toString(int target)

{

    QString retValue;

    retValue = QString::number(target);

    return retValue;

}

QString CUtil::toString(uint target)

{

    QString retValue;

    retValue = QString::number(target);

    return retValue;

}

QString CUtil::toString(double target)

{

    QString retValue;

    retValue = QString::number(target);

    return retValue;

}

QString CUtil::hexaToString(char target)

{

    QString retValue;

    retValue.sprintf("%02x", target);

    return retValue;

}

QString CUtil::hexaToString(uchar target)

{

    QString retValue;

    retValue.sprintf("%02x", target);

    return retValue;

}

QString CUtil::hexaToString(short target, ENDIAN endian)

{

    QString retValue;

    uchar targetBuf[2] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[1];

        targetBuf[1] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

    }

    retValue.sprintf("%02x%02x", targetBuf[0], targetBuf[1]);

    return retValue;

}

QString CUtil::hexaToString(ushort target, ENDIAN endian)

{

    QString retValue;

    uchar targetBuf[2] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[1];

        targetBuf[1] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

    }

    retValue.sprintf("%02x%02x", targetBuf[0], targetBuf[1]);

    return retValue;

}

QString CUtil::hexaToString(int target, ENDIAN endian)

{

    QString retValue;

    uchar targetBuf[4] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[3];

        targetBuf[1] = targetPtr[2];

        targetBuf[2] = targetPtr[1];

        targetBuf[3] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

        targetBuf[2] = targetPtr[2];

        targetBuf[3] = targetPtr[3];

    }

    retValue.sprintf("%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

    return retValue;

}

QString CUtil::hexaToString(uint target, ENDIAN endian)

{

    QString retValue;

    uchar targetBuf[4] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[3];

        targetBuf[1] = targetPtr[2];

        targetBuf[2] = targetPtr[1];

        targetBuf[3] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

        targetBuf[2] = targetPtr[2];

        targetBuf[3] = targetPtr[3];

    }

    retValue.sprintf("%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

    return retValue;

}

//typecast

QString ucharArrayToString(uchar* str)

{

    QString retValue((char*)str);

    return retValue;

}

QString ucharArrayToString(uCharArrayStream& stream)

{

    QString retValue((char*)stream.constData());

    return retValue;

}

#else

using namespace std;

NS_SUGENTECH_BEGIN

//다른 타입을 std::string 객체로 변환

string CUtil::toString(char target)

{

    string str;

    str.push_back(target);

    return str;

}

string CUtil::toString(uchar target)

{

    string str;

    str.push_back((char)target);

    return str;

}

string CUtil::toString(short target)

{

    string str ;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%d", target);

#else

    sprintf(buf, "%d", target);

#endif

    str = buf;

    return str;

}

string CUtil::toString(ushort target)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%d", target);

#else

    sprintf(buf, "%d", target);

#endif

    str = buf;

    return str;

}

string CUtil::toString(int target)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%d", target);

#else

    sprintf(buf, "%d", target);

#endif

    str = buf;

    return str;

}

string CUtil::toString(uint target)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%u", target);

#else

    sprintf(buf, "%u", target);

#endif

    str = buf;

    return str;

}

string CUtil::toString(double target)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%lf", target);

#else

    sprintf(buf, "%lf", target);

#endif

    str = buf;

    return str;

}

//16진수 변환 함수 (다른타입을 std::string으로변환)

string CUtil::hexaToString(char target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%02x", target);

#else

    sprintf(buf, "%02x", target);

#endif

    str = buf;

    return str;

}

string CUtil::hexaToString(uchar target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

#ifdef _WIN32

    sprintf_s(buf, "%02x", target);

#else

    sprintf(buf, "%02x", target);

#endif

    str = buf;

    return str;

}

string CUtil::hexaToString(short target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

    uchar targetBuf[2] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[1];

        targetBuf[1] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

    }

#ifdef _WIN32

    sprintf_s(buf, "%02x%02x", targetBuf[0], targetBuf[1]);

#else

    sprintf(buf, "%02x%02x", targetBuf[0], targetBuf[1]);

#endif

    str = buf;

    return str;

}

string CUtil::hexaToString(ushort target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

    uchar  targetBuf[2] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[1];

        targetBuf[1] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

    }

#ifdef _WIN32

    sprintf_s(buf, "%02x%02x", targetBuf[0], targetBuf[1]);

#else

    sprintf(buf, "%02x%02x", targetBuf[0], targetBuf[1]);

#endif

    str = buf;

    return str;

}

string CUtil::hexaToString(int target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

    uchar  targetBuf[4] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[3];

        targetBuf[1] = targetPtr[2];

        targetBuf[2] = targetPtr[1];

        targetBuf[3] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

        targetBuf[2] = targetPtr[2];

        targetBuf[3] = targetPtr[3];

    }

#ifdef _WIN32

    sprintf_s(buf, "%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

#else

    sprintf(buf, "%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

#endif

    str = buf;

    return str;

}

string CUtil::hexaToString(uint target, CUtil::ENDIAN endian)

{

    string str;

    char buf[256] = { 0, };

    uchar  targetBuf[4] = { 0, };

    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)

    {

        targetBuf[0] = targetPtr[3];

        targetBuf[1] = targetPtr[2];

        targetBuf[2] = targetPtr[1];

        targetBuf[3] = targetPtr[0];

    }

    else

    {

        targetBuf[0] = targetPtr[0];

        targetBuf[1] = targetPtr[1];

        targetBuf[2] = targetPtr[2];

        targetBuf[3] = targetPtr[3];

    }

#ifdef _WIN32

    sprintf_s(buf, "%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

#else

    sprintf(buf, "%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);

#endif

    str = buf;

    return str;

}

#endif

#ifdef USE_QT

void CUtil::messageBox(const char* str)

{

    QMessageBox msgBox;

    msgBox.setText(str);

    msgBox.exec();

}

void CUtil::messageBox(const uchar *str)

{

    QMessageBox msgBox;

    msgBox.setText((char*)str);

    msgBox.exec();

}

#endif

#include <vector>

void main()

{

std::vector<int> sortVector; // 값은 pushback으로 아무값이나 채워넣자 

std::sort(sortVector.begin(), sortVector.end()); //끗

}

/////////// 구조체도 sort함수를 사용할 수 있다! /////////

struct test

{

   int x;

   int y;

};

//만약 클래스를 사용한다면 Static클래스로 만들어야한다.

bool sort(const test& first, const test& second)

{

    return first.x < second.x; // 비교하고싶은 값 반드시 Lvalue < Rvalue형태가 되어야함.

}

void main()

{

    std::vector<test> sortStruct; //역시 값은 아무값이나 pushback으로

    std::sort(sortStruct.begin(), sortStruct.end(), &sort); //클래스안의 멤버 함수를 사용한다면 public접근설정하고 스코프를 앞에 기재

}

웅.. 문서들보면 가끔 private struct붙은애들이있는데... 대충 이런패턴으로쓰는듯하다

스마트 포인터를 이용한 private 변수관리법인데

//.h

#include <QScopedPointer>

class test 

{

 private:

   struct privateStruct; //전방선언

private:

 QScopedPointer<privateStruct> d;

};

//.cpp

...

struct test::privateStruct

{

QString 쏼라쏼라;

QString 나는멤버변수;

};

test::test() :

   d(new privateStruct)

{

}

요런식으로..

이런방식을 쓸때 가장 장점은 불필요한 Include를 헤더에 하지않아도된다.

정의가 필요한녀석들은 cpp에 몰아넣을수있기때문..