C++博客-我喜欢生命本身的挑战！

用VC调整显示器的分辨率 zz

Alina-zl — Tue, 24 Mar 2009 03:19:00 GMT

调整分辨率的代码如下：
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中用以上代码将其改回原值。”

Alina-zl 2009-03-24 11:19 发表评论

vc2005中没有classwizard这个命令了 2005下怎么添加鼠标事件

Alina-zl — Tue, 30 Dec 2008 03:51:00 GMT

vc2005中没有classwizard这个命令了

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

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

比如添加消息映射。你选定了一个类后，在属性点击右键选择属性
在属性窗口中点击那个像闪电样的图标就会出现一系列的消息供你选择，点击小方快样子的图标就会出现虚函数或者重载

至于添加类，直接在工程名称上点右键选择添加类的命令即可

添加变量，可以在类名称上点右键，选择添加变量

Alina-zl 2008-12-30 11:51 发表评论

'IDD_DIALOG1' : undeclared identifier

Alina-zl — Tue, 16 Dec 2008 11:20:00 GMT

error C2065: 'IDD_DIALOG1' : undeclared identifier

解决办法:

加#include 'resource.h'

Alina-zl 2008-12-16 19:20 发表评论

MFC与namespace的冲突问题

Alina-zl — Fri, 21 Nov 2008 03:21:00 GMT

把代码从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
# include
# include

namespace vecmat {

namespace internal {

template
struct is_false {};

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

} // end of namespace internal

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

template
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
  explicit inline Vector(const U tab[N]) {
   for (unsigned i = 0; i < N; i++)
    _coord[i] = (T)tab[i];
  }

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

  template
  explicit inline Vector(const Vector& 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& normalize() {
   value_type n = norm();
   for (unsigned i = 0; i < N; i++)
    _coord[i] /= n;
   return *this;
  }

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

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

  inline Vector& max(const Vector& 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
  inline Vector& operator=(const Vector& v) {
   if (this != &v)
    for (unsigned i = 0; i < N; i++)
     _coord[i] = (T)v[i];
   return *this;
  }

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

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

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

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

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

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

  inline bool operator<(const Vector& v) const {
   for (unsigned i = 0; 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& v) const {
   for (unsigned i=0; 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 Vec2 : public Vector
{
public:

typedef typename Vector::value_type value_type;

inline Vec2() : Vector() {}

template
explicit inline Vec2(const U tab[2]) : Vector(tab) {}

template
explicit inline Vec2(const std::vector& tab) : Vector(tab) {}

template
inline Vec2(const Vector& v) : Vector(v) {}

  inline Vec2(const value_type x,
   const value_type y = 0) : Vector() {
    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 HVec3 : public Vector
{
public:

typedef typename Vector::value_type value_type;

inline HVec3() : Vector() {}

template
explicit inline HVec3(const U tab[4]) : Vector(tab) {}

template
explicit inline HVec3(const std::vector& tab) : Vector(tab) {}

template
inline HVec3(const Vector& v) : Vector(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
  inline HVec3(const Vector& 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
  inline HVec3(const Vector& 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 Vec3 : public Vector
{
public:

typedef typename Vector::value_type value_type;

inline Vec3() : Vector() {}

template
explicit inline Vec3(const U tab[3]) : Vector(tab) {}

template
explicit inline Vec3(const std::vector& tab) : Vector(tab) {}

template
inline Vec3(const Vector& v) : Vector(v) {}

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

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

  template
  inline Matrix(const Matrix& 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 transpose() const {
   Matrix 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
  inline Matrix& operator=(const Matrix& 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
  inline Matrix& operator+=(const Matrix& 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
  inline Matrix& operator-=(const Matrix& 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
  inline Matrix& 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
  inline Matrix& 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 SquareMatrix : public Matrix
{
public:

typedef T value_type;

inline SquareMatrix() : Matrix() {}

template
explicit inline SquareMatrix(const U tab[__SIZE]) : Matrix(tab) {}

template
explicit inline SquareMatrix(const std::vector& tab) : Matrix(tab) {}

template
inline SquareMatrix(const Matrix& m) : Matrix(m) {}

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

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

template
inline Vector operator+(const Vector& v1,
  const Vector& v2) {
   Vector res(v1);
   res += v2;
   return res;
}

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

template
inline Vector operator*(const typename Vector::value_type r,
  const Vector& v) {
   Vector res(v);
   res *= r;
   return res;
}

template
inline Vector operator/(const Vector& v,
  const typename Vector::value_type r) {
   Vector res(v);
   if (r)
    res /= r;
   return res;
}

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

// cross product for 3D Vectors
template
inline Vec3 operator^(const Vector& v1,
  const Vector& v2) {
   Vec3 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
inline std::ostream& operator<<(std::ostream& s,
  const Vector& v) {
   unsigned i;
   s << "[";
   for (i = 0; i < N - 1; i++)
    s << v[i] << ", ";
   s << v[i] << "]";
   return s;
}

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

template
inline Matrix
  operator+(const Matrix& m1,
  const Matrix& m2) {
   Matrix res(m1);
   res += m2;
   return res;
}

template
inline Matrix
  operator-(const Matrix& m1,
  const Matrix& m2) {
   Matrix res(m1);
   res -= m2;
   return res;
}

template
inline Matrix
  operator*(const Matrix& m1,
  const typename Matrix::value_type lambda) {
   Matrix res(m1);
   res *= lambda;
   return res;
}

template
inline Matrix
  operator*(const typename Matrix::value_type lambda,
  const Matrix& m1) {
   Matrix res(m1);
   res *= lambda;
   return res;
}

template
inline Matrix
  operator/(const Matrix& m1,
  const typename Matrix::value_type lambda) {
   Matrix res(m1);
   res /= lambda;
   return res;
}

template
inline Matrix
  operator*(const Matrix& m1,
  const Matrix& m2) {
   unsigned i, j, k;
   Matrix res;
   typename Matrix::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
inline Vector
operator*(const Matrix& m,
const Vector& v) {

Vector res;
typename Matrix::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
inline std::ostream& operator<<(std::ostream& s,
  const Matrix& 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同上。

问题解决。

Alina-zl 2008-11-21 11:21 发表评论

CString, QString, char*之间的转换

Alina-zl — Wed, 19 Nov 2008 13:39:00 GMT

传给未分配内存的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);
}

Alina-zl 2008-11-19 21:39 发表评论