国产福利电影一区二区三区久久久久成人精品综合 ,欧美亚洲另类久久综合,国产亚洲精午夜久久久久久

2009年3月24日

用VC調整顯示器的分辨率 zz

調整分辨率的代碼如下：
DEVMODE dm;
dm.dmSize = sizeof(DEVMODE) ;
EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dm);
if(dm.dmPelsHeight!=1024||dm.dmPelsWidth!=1280){
if(AfxMessageBox("為了達到最好的顯示效果，建議您使用1280*1024的分辨率，確定嗎？",MB_YESNO)==IDYES){
   LONG result;
   dm.dmBitsPerPel = 32;
   dm.dmPelsHeight = 1024;
   dm.dmPelsWidth = 1280;
   dm.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
   result = ChangeDisplaySettings(&dm,0);
}
}
“如果要在程序啟動時自動自動調整到合適的分辨率，可以將其加入到View的OnInitialUpdate()中，并記錄下dm.dmPelsHeight和dm.dmPelsWidth的值。
要在程序結束時自動調整回原有分辨率，可在MainFrame的OnClose()中用以上代碼將其改回原值。”

如果要在程序啟動時自動自動調整到合適的分辨率，可以將其加入到app的InitInstance()中，并記錄下dm.dmPelsHeight和dm.dmPelsWidth的值。
要在程序結束時自動調整回原有分辨率，可在APP的ExitInstance中用以上代碼將其改回原值。”

posted @ 2009-03-24 11:19 Alina-zl 閱讀(535) | 評論 (0) | 編輯收藏

2008年12月30日

vc2005中沒有classwizard這個命令了 2005下怎么添加鼠標事件

vc2005中沒有classwizard這個命令了

取代classwizard 中的添加消息映射，添加類，等等的功能主要在屬性窗口中

鼠標事件不要手動添加，最好使用下述方法

比如添加消息映射。你選定了一個類后，在屬性點擊右鍵選擇屬性
在屬性窗口中點擊那個像閃電樣的圖標就會出現一系列的消息供你選擇，點擊小方快樣子的圖標就會出現虛函數或者重載

至于添加類，直接在工程名稱上點右鍵選擇添加類的命令即可

添加變量，可以在類名稱上點右鍵，選擇添加變量

posted @ 2008-12-30 11:51 Alina-zl 閱讀(882) | 評論 (0) | 編輯收藏

2008年12月16日

'IDD_DIALOG1' : undeclared identifier

error C2065: 'IDD_DIALOG1' : undeclared identifier

解決辦法:

加#include 'resource.h'

posted @ 2008-12-16 19:20 Alina-zl 閱讀(1979) | 評論 (1) | 編輯收藏

2008年11月21日

MFC與namespace的沖突問題

把代碼從QT移植到MFC的時候，這個文件vecmat.h，出現了如下錯誤：
error C2143: syntax error : missing ',' before ')'
error C2143: syntax error : missing ';' before '}'
error C2059: syntax error : ')'
fatal error C1004: unexpected end-of-file found
等等。
vecmat.h源代碼如下:

#ifndef VECMAT_H
# define VECMAT_H

# include <cmath>
# include <vector>
# include <iostream>

namespace vecmat {

namespace internal {

template <bool B>
struct is_false {};

template <>
 struct is_false<false> {
 static inline void ensure() {}
 };

} // end of namespace internal

//
// Vector class
// - T: value type
// - N: dimension
//
/////////////////////////////////////////////////////////////////////////////

template <class T, unsigned N>
class Vector
{
public:

typedef T value_type;

// constructors

inline Vector() {
 for (unsigned i = 0; i < N; i++)
 _coord[i] = 0;
 }

~Vector() {
 internal::is_false<(N == 0)>::ensure();
 }

template <class U>
 explicit inline Vector(const U tab[N]) {
 for (unsigned i = 0; i < N; i++)
 _coord[i] = (T)tab[i];
 }

template <class U>
 explicit inline Vector(const std::vector& tab) {
 for (unsigned i = 0; i < N; i++)
 _coord[i] = (T)tab[i];
 }

template <class U>
 explicit inline Vector(const Vector<U, N>& v) {
 for (unsigned i = 0; i < N; i++)
 _coord[i] = (T)v[i];
 }

// accessors

  inline value_type operator[](const unsigned i) const {
   return _coord[i];
  }

  inline value_type& operator[](const unsigned i) {
   return _coord[i];
  }

  static inline unsigned dim() {
   return N;
  }

// various useful methods

  inline value_type norm() const {
   return (T)sqrt(squareNorm());
  }

  inline value_type squareNorm() const {
   return (*this) * (*this);
  }

inline Vector<T, N>& normalize() {
 value_type n = norm();
 for (unsigned i = 0; i < N; i++)
 _coord[i] /= n;
 return *this;
 }

inline Vector<T, N>& normalizeSafe() {
 value_type n = norm();
 if (n)
 for (unsigned i=0; i < N; i++)
 _coord[i] /= n;
 return *this;
 }

inline Vector<T, N>& min(const Vector<T, N>& v) {
 for (unsigned i=0; i < N; i++)
 if (_coord[i] > v._coord[i])
 _coord[i] = v._coord[i];
 return *this;
 }

inline Vector<T, N>& max(const Vector<T, N>& v) {
 for (unsigned i=0; i < N; i++)
 if (_coord[i] < v._coord[i])
 _coord[i] = v._coord[i];
 return *this;
 }

  inline const value_type* address() const {
   return _coord;
  }

// classical operators

template <class U>
 inline Vector<T, N>& operator=(const Vector<U, N>& v) {
 if (this != &v)
 for (unsigned i = 0; i < N; i++)
 _coord[i] = (T)v[i];
 return *this;
 }

template <class U>
 inline Vector<T, N>& operator+=(const Vector<U, N>& v) {
 for (unsigned i = 0 ; i < N; i++)
 _coord[i] += (T)v[i];
 return *this;
 }

template <class U>
 inline Vector<T, N>& operator-=(const Vector<U, N>& v) {
 for (unsigned i = 0 ; i < N; i++)
 _coord[i] -= (T)v[i];
 return *this;
 }

template <class U>
 inline Vector<T, N>& operator*=(const U r) {
 for (unsigned i = 0 ; i < N; i++)
 _coord[i] *= r;
 return *this;
 }

template <class U>
 inline Vector<T, N>& operator/=(const U r) {
 if (r)
 for (unsigned i = 0 ; i < N; i++)
 _coord[i] /= r;
 return *this;
 }

inline bool operator==(const Vector<T, N>& v) const {
 for(unsigned i = 0; i < N; i++)
 if (_coord[i] != v[i])
 return false;
 return true;
 }

inline bool operator!=(const Vector<T, N>& v) const {
 for(unsigned i = 0; i < N; i++)
 if (_coord[i] != v[i])
 return true;
 return false;
 }

inline bool operator<(const Vector<T, N>& v) const {
 for (unsigned i = 0; i<N; i++) {
 if (_coord[i] < v[i])
 return true;
 if (_coord[i] > v[i])
 return false;
 if (_coord[i] == v[i])
 continue;
 }
 return false;
 }

inline bool operator>(const Vector<T, N>& v) const {
 for (unsigned i=0; i<N; i++) {
 if(_coord[i] > v[i])
 return true;
 if(_coord[i] < v[i])
 return false;
 if(_coord[i] == v[i])
 continue;
 }
 return false;
 }

protected:

  value_type _coord[N];
  enum {
   _dim = N,
  };
};

//
// Vec2 class (2D Vector)
// - T: value type
//
/////////////////////////////////////////////////////////////////////////////

template <class T>
class Vec2 : public Vector<T, 2>
{
public:

typedef typename Vector<T, 2>::value_type value_type;

inline Vec2() : Vector<T, 2>() {}

template <class U>
explicit inline Vec2(const U tab[2]) : Vector<T, 2>(tab) {}

template <class U>
explicit inline Vec2(const std::vector& tab) : Vector<T, 2>(tab) {}

template <class U>
inline Vec2(const Vector<U, 2>& v) : Vector<T, 2>(v) {}

inline Vec2(const value_type x,
 const value_type y = 0) : Vector<T, 2>() {
 this->_coord[0] = (T)x;
 this->_coord[1] = (T)y;
 }

  inline value_type x() const {
   return this->_coord[0];
  }

  inline value_type& x() {
   return this->_coord[0];
  }

  inline value_type y() const {
   return this->_coord[1];
  }

  inline value_type& y() {
   return this->_coord[1];
  }
};

//
// HVec3 class (3D Vector in homogeneous coordinates)
// - T: value type
//
/////////////////////////////////////////////////////////////////////////////

template <class T>
class HVec3 : public Vector<T, 4>
{
public:

typedef typename Vector<T, 4>::value_type value_type;

inline HVec3() : Vector<T, 4>() {}

template <class U>
explicit inline HVec3(const U tab[4]) : Vector<T, 4>(tab) {}

template <class U>
explicit inline HVec3(const std::vector& tab) : Vector<T, 4>(tab) {}

template<class U>
inline HVec3(const Vector<U, 4>& v) : Vector<T, 4>(v) {}

  inline HVec3(const value_type sx,
   const value_type sy = 0,
   const value_type sz = 0,
   const value_type s = 1) {
    this->_coord[0] = sx;
    this->_coord[1] = sy;
    this->_coord[2] = sz;
    this->_coord[3] = s;
  }

template <class U>
 inline HVec3(const Vector<U, 3>& sv) {
 this->_coord[0] = (T)sv[0];
 this->_coord[1] = (T)sv[1];
 this->_coord[2] = (T)sv[2];
 this->_coord[3] = (T)1;
 }

template <class U>
 inline HVec3(const Vector<U, 3>& sv,
 const U) {
 this->_coord[0] = (T)sv[0];
 this->_coord[1] = (T)sv[1];
 this->_coord[2] = (T)sv[2];
 this->_coord[3] = (T)s;
 }

  inline value_type sx() const {
   return this->_coord[0];
  }

  inline value_type& sx() {
   return this->_coord[0];
  }

  inline value_type sy() const {
   return this->_coord[1];
  }

  inline value_type& sy() {
   return this->_coord[1];
  }

  inline value_type sz() const {
   return this->_coord[2];
  }

  inline value_type& sz() {
   return this->_coord[2];
  }

  inline value_type s() const {
   return this->_coord[3];
  }

  inline value_type& s() {
   return this->_coord[3];
  }

// Acces to non-homogeneous coordinates in 3D

  inline value_type x() const {
   return this->_coord[0] / this->_coord[3];
  }

  inline value_type y() const {
   return this->_coord[1] / this->_coord[3];
  }

  inline value_type z() const {
   return this->_coord[2] / this->_coord[3];
  }
};

//
// Vec3 class (3D Vector)
// - T: value type
//
/////////////////////////////////////////////////////////////////////////////

template <class T>
class Vec3 : public Vector<T, 3>
{
public:

typedef typename Vector<T, 3>::value_type value_type;

inline Vec3() : Vector<T, 3>() {}

template <class U>
explicit inline Vec3(const U tab[3]) : Vector<T, 3>(tab) {}

template <class U>
explicit inline Vec3(const std::vector& tab) : Vector<T, 3>(tab) {}

template<class U>
inline Vec3(const Vector<U, 3>& v) : Vector<T, 3>(v) {}

template<class U>
 inline Vec3(const HVec3& v) {
 this->_coord[0] = (T)v.x();
 this->_coord[1] = (T)v.y();
 this->_coord[2] = (T)v.z();
 }

inline Vec3(const value_type x,
 const value_type y = 0,
 const value_type z = 0) : Vector<T, 3>() {
 this->_coord[0] = x;
 this->_coord[1] = y;
 this->_coord[2] = z;
 }

  inline value_type x() const {
   return this->_coord[0];
  }

  inline value_type& x() {
   return this->_coord[0];
  }

  inline value_type y() const {
   return this->_coord[1];
  }

  inline value_type& y() {
   return this->_coord[1];
  }

  inline value_type z() const {
   return this->_coord[2];
  }

  inline value_type& z() {
   return this->_coord[2];
  }
};

//
// Matrix class
//    - T: value type
//    - M: rows
//    - N: cols
//
/////////////////////////////////////////////////////////////////////////////

// Dirty, but icc under Windows needs this
# define _SIZE (M * N)

template <class T, unsigned M, unsigned N>
class Matrix
{
public:

typedef T value_type;

inline Matrix() {
 for (unsigned i = 0; i < _SIZE; i++)
 this->_coord[i] = 0;
 }

~Matrix() {
 internal::is_false<(M == 0)>::ensure();
 internal::is_false<(N == 0)>::ensure();
 }

template <class U>
 explicit inline Matrix(const U tab[M][N]) {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] = tab[i][j];
 }

template <class U>
 explicit inline Matrix(const U tab[_SIZE]) {
 for (unsigned i = 0; i < _SIZE; i++)
 this->_coord[i] = tab[i];
 }

template <class U>
 explicit inline Matrix(const std::vector& tab) {
 for (unsigned i = 0; i < _SIZE; i++)
 this->_coord[i] = tab[i];
 }

template <class U>
 inline Matrix(const Matrix<U, M, N>& m) {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] = (T)m(i, j);
 }

  inline value_type operator()(const unsigned i, const unsigned j) const {
   return this->_coord[i * N + j];
  }

  inline value_type& operator()(const unsigned i, const unsigned j) {
   return this->_coord[i * N + j];
  }

  static inline unsigned rows() {
   return M;
  }

  static inline unsigned cols() {
   return N;
  }

inline Matrix<T, M, N> transpose() const {
 Matrix<T, N, M> res;
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 res(j,i) = this->_coord[i * N + j];
 return res;
 }

inline void getArray(value_type res[M][N]) const {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 res[i][j] = this->_coord[i * N + j];
 }

inline void getArray(value_type res[_SIZE]) const {
 for (unsigned i = 0; i < _SIZE; i++)
 res[i] = this->_coord[i];
 }

  inline const value_type* address() const {
   return this->_coord;
  }

template <class U>
 inline Matrix<T, M, N>& operator=(const Matrix<U, M, N>& m) {
 if (this != &m)
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] = (T)m(i, j);
 return *this;
 }

template <class U>
 inline Matrix<T, M, N>& operator+=(const Matrix<U, M, N>& m) {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] += (T)m(i, j);
 return *this;
 }

template <class U>
 inline Matrix<T, M, N>& operator-=(const Matrix<U, M, N>& m) {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] -= (T)m(i, j);
 return *this;
 }

template <class U>
 inline Matrix<T, M, N>& operator*=(const U lambda) {
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] *= lambda;
 return *this;
 }

template <class U>
 inline Matrix<T, M, N>& operator/=(const U lambda) {
 if (lambda)
 for (unsigned i = 0; i < M; i++)
 for (unsigned j = 0; j < N; j++)
 this->_coord[i * N + j] /= lambda;
 return *this;
 }

protected:

value_type _coord[_SIZE];
};

//
// SquareMatrix class
// - T: value type
// - N: rows & cols
//
/////////////////////////////////////////////////////////////////////////////

// Dirty, but icc under Windows needs this
# define __SIZE (N * N)

template <class T, unsigned N>
class SquareMatrix : public Matrix<T, N, N>
{
public:

typedef T value_type;

inline SquareMatrix() : Matrix<T, N, N>() {}

template <class U>
explicit inline SquareMatrix(const U tab[__SIZE]) : Matrix<T, N, N>(tab) {}

template <class U>
explicit inline SquareMatrix(const std::vector& tab) : Matrix<T, N, N>(tab) {}

template <class U>
inline SquareMatrix(const Matrix<U, N, N>& m) : Matrix<T, N, N>(m) {}

static inline SquareMatrix<T, N> identity() {
 SquareMatrix<T, N> res;
 for (unsigned i = 0; i < N; i++)
 res(i, i) = 1;
 return res;
 }
};

//
// Vector external functions
//
/////////////////////////////////////////////////////////////////////////////

template <class T, unsigned N>
inline Vector<T, N> operator+(const Vector<T, N>& v1,
 const Vector<T, N>& v2) {
 Vector<T, N> res(v1);
 res += v2;
 return res;
}

template <class T, unsigned N>
inline Vector<T, N> operator-(const Vector<T, N>& v1,
 const Vector<T, N>& v2) {
 Vector<T, N> res(v1);
 res -= v2;
 return res;
}
template <class T, unsigned N>
inline Vector<T, N> operator*(const Vector<T, N>& v,
 const typename Vector<T, N>::value_type r) {
 Vector<T, N> res(v);
 res *= r;
 return res;
}

template <class T, unsigned N>
inline Vector<T, N> operator*(const typename Vector<T, N>::value_type r,
 const Vector<T, N>& v) {
 Vector<T, N> res(v);
 res *= r;
 return res;
}

template <class T, unsigned N>
inline Vector<T, N> operator/(const Vector<T, N>& v,
 const typename Vector<T, N>::value_type r) {
 Vector<T, N> res(v);
 if (r)
 res /= r;
 return res;
}

// dot product
template <class T, unsigned N>
inline typename Vector<T, N>::value_type operator*(const Vector<T, N>& v1,
 const Vector<T, N>& v2) {
 typename Vector<T, N>::value_type sum = 0;
 for (unsigned i = 0; i < N; i++)
 sum += v1[i] * v2[i];
 return sum;
}

// cross product for 3D Vectors
template <typename T>
inline Vec3<T> operator^(const Vector<T, 3>& v1,
 const Vector<T, 3>& v2) {
 Vec3<T> res(v1[1] * v2[2] - v1[2] * v2[1],
 v1[2] * v2[0] - v1[0] * v2[2],
 v1[0] * v2[1] - v1[1] * v2[0]);
 return res;
}

// stream operator
template <class T, unsigned N>
inline std::ostream& operator<<(std::ostream& s,
 const Vector<T, N>& v) {
 unsigned i;
 s << "[";
 for (i = 0; i < N - 1; i++)
 s << v[i] << ", ";
 s << v[i] << "]";
 return s;
}

//
// Matrix external functions
//
/////////////////////////////////////////////////////////////////////////////

template <class T, unsigned M, unsigned N>
inline Matrix<T, M, N>
 operator+(const Matrix<T, M, N>& m1,
 const Matrix<T, M, N>& m2) {
 Matrix<T, M, N> res(m1);
 res += m2;
 return res;
}

template <class T, unsigned M, unsigned N>
inline Matrix<T, M, N>
 operator-(const Matrix<T, M, N>& m1,
 const Matrix<T, M, N>& m2) {
 Matrix<T, M, N> res(m1);
 res -= m2;
 return res;
}

template <class T, unsigned M, unsigned N>
inline Matrix<T, M, N>
 operator*(const Matrix<T, M, N>& m1,
 const typename Matrix<T, M, N>::value_type lambda) {
 Matrix<T, M, N> res(m1);
 res *= lambda;
 return res;
}

template <class T, unsigned M, unsigned N>
inline Matrix<T, M, N>
 operator*(const typename Matrix<T, M, N>::value_type lambda,
 const Matrix<T, M, N>& m1) {
 Matrix<T, M, N> res(m1);
 res *= lambda;
 return res;
}

template <class T, unsigned M, unsigned N>
inline Matrix<T, M, N>
 operator/(const Matrix<T, M, N>& m1,
 const typename Matrix<T, M, N>::value_type lambda) {
 Matrix<T, M, N> res(m1);
 res /= lambda;
 return res;
}

template <class T, unsigned M, unsigned N, unsigned P>
inline Matrix<T, M, P>
 operator*(const Matrix<T, M, N>& m1,
 const Matrix<T, N, P>& m2) {
 unsigned i, j, k;
 Matrix<T, M, P> res;
 typename Matrix<T, N, P>::value_type scale;

for (j = 0; j < P; j++) {
 for (k = 0; k < N; k++) {
 scale = m2(k, j);
 for (i = 0; i < N; i++)
 res(i, j) += m1(i, k) * scale;
 }
 }
 return res;
}

template <class T, unsigned M, unsigned N>
inline Vector<T, M>
operator*(const Matrix<T, M, N>& m,
const Vector<T, N>& v) {

Vector<T, M> res;
typename Matrix<T, M, N>::value_type scale;

for (unsigned j = 0; j < M; j++) {
 scale = v[j];
 for (unsigned i = 0; i < N; i++)
 res[i] += m(i, j) * scale;
 }
 return res;
}

// stream operator
template <class T, unsigned M, unsigned N>
inline std::ostream& operator<<(std::ostream& s,
 const Matrix<T, M, N>& m) {
 unsigned i, j;
 for (i = 0; i < M; i++) {
 s << "[";
 for (j = 0; j < N - 1; j++)
 s << m(i, j) << ", ";
 s << m(i, j) << "]" << std::endl;
 }
 return s;
}

} // end of namespace vecmat

#endif // VECMAT_H

原因是在windows的頭文件里max，min已經被定義成宏了，所以要出問題!
解決方法：
用
#ifdef max
#undef max
#endif
去掉max的定義。
min同上。

問題解決。

posted @ 2008-11-21 11:21 Alina-zl 閱讀(799) | 評論 (0) | 編輯收藏

2008年11月19日

CString, QString, char*之間的轉換

傳給未分配內存的const char* （LPCTSTR）指針.
   CString cstr(asdd);
   const char* ch = (LPCTSTR)cstr;
   ch指向的地址和cstr相同。但由于使用const保證ch不會修改，所以安全.2.傳給未分配內存的指針.
    CString cstr = "ASDDSD";
    char *ch = cstr.GetBuffer(cstr1.GetLength() + 1);
    cstr.ReleaseBuffer();
    //修改ch指向的值等于修改cstr里面的值.
    //PS:用完ch后,不用delete ch,因為這樣會破壞cstr內部空間,容易造成程序崩潰.
3.第二種用法。把CString 值賦給已分配內存的char *。
    CString cstr1 = "ASDDSD";
    int strLength = cstr1.GetLength() + 1;
    char *pValue = new char[strLength];
    strncpy(pValue, cstr1, strLength);
4.第三種用法.把CString 值賦給已分配內存char[]數組.
    CString cstr2 = "ASDDSD";
    int strLength1 = cstr1.GetLength() + 1;
    char chArray[100];
    memset(chArray,0, sizeof(bool) * 100); //將數組的垃圾內容清空.
    strncpy(chArray, cstr1, strLength1);

如果上述都不行：
CString轉換為char*
 CString origCString("Hello, World!");
 wchar_t* wCharString = origCString.GetBuffer(origCString.GetLength()+1);
 size_t origsize = wcslen(wCharString) + 1;
 size_t convertedChars = 0;
 char *CharString;
 CharString=new char(origsize);
 wcstombs_s(&convertedChars, CharString, origsize, wCharString , _TRUNCATE);
 cout << CharString << endl;
成功輸出字符串"Hello,World"

原因：
原來在VC++ 2005以前，應用程序默認都是關閉對Unicode的支持的，而在VC2005中，默認打開了對它的支持，CString對應的字符串應該是TCHAR，TCHAR的定義是這樣的，
        #ifdef _UNICODE
        typedef wchar_t TCHAR    ;
        #else
        typedef char TCHAR;
        #endif
所以在工程中應該可以關閉對于Unicode的支持，從而可以直接轉換。這個做法是右擊工程名—〉Property—〉General中的character set中選擇notset，這樣，本文開頭的那段代碼就可以正確的執行了。

如何將QString轉換為char *或者相反

How can I convert a QString to char* and vice versa ?(trolltech)

Answer:
In order to convert a QString to a char*, then you first need to get a latin1 representation of the string by calling toLatin1() on it which will return a QByteArray. Then call data() on the QByteArray to get a pointer to the data stored in the byte array. See the documentation:

See the following example for a demonstration:

int main(int argc, char **argv)
{
QApplication app(argc, argv);
QString str1 = "Test";
QByteArray ba = str1.toLatin1();
const char *c_str2 = ba.data();
printf("str2: %s", c_str2);
return app.exec();
}
Note that it is necessary to store the bytearray before you call data() on it, a call like the following
const char *c_str2 = str2.toLatin1().data();

will make the application crash as the QByteArray has not been stored and hence no longer exists.

To convert a char* to a QString you can use the QString constructor that takes a QLatin1String, e.g:

QString string = QString(QLatin1String(c_str2)) ;

還有其他多種方法：

方法一 -----------------------------------------
#define G2U(s) ( QTextCodec::codecForName("GBK")->toUnicode(s) )
#define U2G(s) ( QTextCodec::codecForName("GBK")->fromUnicode(s) )

QString str;
QCString cstr;

str = G2U("中文輸入");
cstr = U2G(str);

QCString有這樣一個重載運算符
operator const char * () const

可以這樣
printf("%s\n", (const char*) cstr);
或是copy出來
char buf[1024];
strcpy(buf, (const char*) cstr);

方法二 -----------------------------------------
如果是中文系統

直接用 (const char*) str.local8Bit()
例如
printf("%s", (const char*) str.local8Bit());

str是一個QString

方法三 -----------------------------------------
char str[64];
QTextCodec *textcod = QTextCodec::codecForName("GBK");
QCString string1 = textcod ->fromUnicode(listbox1->currentText());
strcpy(str,string1);

QString和Std::string

從char*到 QString可以從fromLocal8Bit()轉化
std::string有c_str()的函數使再轉化為char*

QString有toAscii()記不清了

你可以看看.

又是我的粗心釀成大錯，我重新查看了一下Qt文檔，原來Qt可以直接從std::wstring產生一個QString，用QString::fromStdWString(const std::wstring &)這個靜態成員函數即可。我試了試用std::string的c_str()返回的char *構造的QString不能再保存原先的中文信息，而用std::wstring構造的QString則可以用qDebug()輸出原先的中文信息
GB編碼與UTF8編碼的轉換
在主函數app后加上這句：

QUOTE:

QTextCodec::setCodecForLocale(QTextCodec::codecForName("GB18030"));

然后是從UTF8編碼到GB編碼的字符串轉換方法：

QUOTE:

QString Utf8_To_GB(QString strText)
{
return QString::fromUtf8(strText.toLocal8Bit().data());
}

至于從GB到UTF8，那大家就經常用了：

QUOTE:

QString GB_To_Utf8(char *strText)
{
return QString::fromLocal8Bit(strText);
}

posted @ 2008-11-19 21:39 Alina-zl 閱讀(13273) | 評論 (1) | 編輯收藏

僅列出標題

用VC調整顯示器的分辨率 zz

vc2005中沒有classwizard這個命令了 2005下怎么添加鼠標事件

'IDD_DIALOG1' : undeclared identifier

MFC與namespace的沖突問題

CString, QString, char*之間的轉換

導航

統計

常用鏈接

留言簿(1)

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜