在线观看精品一区,欧美激情1区2区3区,亚洲一级一区

vc2005中没有classwizard�q�个命��o�?2005下怎么��d��鼠标事�g

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

vc2005中没有classwizard�q�个命��o�?

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

鼠标事�g不要手动��d��Q�最好��用下�q�方�?/span>

比如��d��消息映射。你选定了一个类后，在属性点��d��?选择属�?
在属性窗口中点击那个像闪甉|��?图标 ��׃��出现一�p�d��的消息供你选择 �Q�点�?��方快样子的图标 ��׃��出现虚函数或者重�?

至于��d��c�，直接在工�E�名�U�C��点右�?选择 ��d��cȝ��命��o 卛_��

��d��变量 �Q�可以在�c�d��U�C��点右键，选择��d��变量

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 发表评论

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

把代码从QT�U�L��到MFC的时候，�q�个文�gvecmat.h�Q�出��C��如下错误�Q?br>error C2143: syntax error : missing ',' before ')'
error C2143: syntax error : missing ';' before '}'
error C2059: syntax error : ')'
fatal error C1004: unexpected end-of-file found
�{�等�?br>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的头文�g里max�Q�min已经被定义成宏了�Q�所以要出问�?
解决�Ҏ��Q?br>�?br>#ifdef max
#undef max
#endif
��L��max的定义�?br>min同上�?/span>

问题解决�?/p>

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

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

传给未分配内存的const char* �Q�LPCTSTR�Q�指�?
   CString cstr(asdd);
   const char* ch = (LPCTSTR)cstr;
   ch指向的地址和cstr相同。但�׃��使用const保证ch不会修改�Q�所以安�?2.传给未分配内存的指针.
    CString cstr = "ASDDSD";
    char *ch = cstr.GetBuffer(cstr1.GetLength() + 1);
    cstr.ReleaseBuffer();
    //修改ch指向的值等于修改cstr里面的�?
    //PS:用完ch�?不用delete ch,因�ؓ�q�样会破坏cstr内部�I�间,�Ҏ��造成�E�序崩溃.
3.�W�二�U�用法。把CString ��D��l�已分配内存的char *�?br>    CString cstr1 = "ASDDSD";
    int strLength = cstr1.GetLength() + 1;
    char *pValue = new char[strLength];
    strncpy(pValue, cstr1, strLength);
4.�W�三�U�用�?把CString ��D��l�已分配内存char[]数组.
    CString cstr2 = "ASDDSD";
    int strLength1 = cstr1.GetLength() + 1;
    char chArray[100];
    memset(chArray,0, sizeof(bool) * 100); //��数�l�的垃圾内容清空.
    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"

原因�Q?br>原来在VC++ 2005以前�Q�应用程序默认都是关闭对Unicode的支持的�Q�而在VC2005中，默认打开了对它的支持�Q�CString对应的字�W�串应该是TCHAR�Q�TCHAR的定义是�q�样的，
        #ifdef _UNICODE
        typedef wchar_t TCHAR    ;
        #else
        typedef char TCHAR;
        #endif
所以在工程中应该可以关闭对于Unicode的支持，从而可以直接�{换。这个做法是叛_��工程名—〉Property—〉General中的character set中选择notset�Q�这��P��本文开头的那段代码��可以正��的执行了�?/font>

如何��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)) ;

�q�有其他多种�Ҏ��Q?/p>

�Ҏ��一 -----------------------------------------
#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

可以�q�样
printf("%s\n", (const char*) cstr);
或是copy出来
char buf[1024];
strcpy(buf, (const char*) cstr);

�Ҏ��?-----------------------------------------
如果是中文系�l?/p>

直接�?nbsp; (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()的函��C��再�{化�ؓchar*

QString有toAscii()��C��清了

你可以看�?

又是我的�_�心酿成大错�Q�我重新查看了一下Qt文档�Q�原来Qt可以直接从std::wstring产生一个QString�Q�用QString::fromStdWString(const std::wstring &)�q�个静态成员函数即可。我试了试用std::string的c_str()�q�回的char *构造的QString不能再保存原先的中文信息�Q�而用std::wstring构造的QString则可以用qDebug()输出原先的中文信�?
GB�~�码与UTF8�~�码的�{�?br>在主函数app后加上这句：

QUOTE:

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

然后是从UTF8�~�码到GB�~�码的字�W�串转换�Ҏ��Q?/p>

QUOTE:

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

至于从GB到UTF8�Q�那大家��q��常用了：

QUOTE:

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

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