C++博客-分享知识-随笔分类-C/C++细节知识

关于时间的几个变量

史传红 — Fri, 29 Dec 2006 03:07:00 GMT

最近看到了关于时间上面的几个变量：timeval,time_t,tm。请了解的详细说说它们的定义和相关的调用函数，让大家一起来学习，呵呵。

史传红 2006-12-29 11:07 发表评论

VC中视图(View)通知对话框(Dialog)的方法

史传红 — Fri, 28 Apr 2006 13:47:00 GMT

摘要: 在利用 VC ＋ MFC 编程的时候，我们往往能碰到这种情况：在一个模拟程序中（如有些游戏），需要实时显示一些属性的值（文字或者图形），这个时候我们可以重新打开一个对话框（可以是一个模态或者非模态的）来显示这些信息，本文以模态对话框为例，简单实现这个技术。以下代码阴影部分是我利用 ClassWizard 加的，蓝色部分是我手工加的。其余是... 阅读全文

史传红 2006-04-28 21:47 发表评论

一个读取数据库的问题

史传红 — Tue, 25 Apr 2006 13:11:00 GMT

最近由于要发布交通仿真程序(TSS)的Demo版，以前程序使用的是基于SQL2000数据库的数据源，现在需要改成基于Access数据库，但是在改成Access数据库之后，发现仿真的时候，前台客户端程序可以正常读取Access数据库，而后台服务器进程不能够正确的读取数据库。为什么使用SQL2000数据库的时候没有问题，而使用Access数据库就会出现问题呢？经过调试终于找出了问题：当模拟开始的时候，前台此时正在保存该方案号的信息到数据库中，而此时后台服务器程序也紧接着读取该方案号信息，此时我觉得可能是Access数据库在处理并发的时候出现了问题。以致于服务器进程读取的方案号信息不正确，接下来的其它信息也就不正确了，这就造成了不能正常模拟。〔SQL数据库在处理这种情况时，可能是有一个很好的机制保证了数据的正确性。〕

史传红 2006-04-25 21:11 发表评论

VC中访问Access数据库的方法（不需要用户建立ODBC数据源）

史传红 — Thu, 13 Apr 2006 05:01:00 GMT

摘要: 由于项目要发布一个单机版，原来用的数据库是大型数据库。需要在单机版中用Access比较方便，另外也不能让用户自己创建数据源，最终的方案就是在程序中直接访问（*.mdb）Access数据库文件，下面简要给出在VC6.0中的访问Access数据库文件的方法：......
阅读全文

史传红 2006-04-13 13:01 发表评论

C++ Thinking 学习笔记之二----说说C/C++的预处理宏

史传红 — Wed, 12 Apr 2006 07:57:00 GMT

在C/C++中，预处理宏需要注意几点：
1）看看两个语句：
typedef struct _person
{
char m_strName[16];
int m_nAge;
}*TPPerson;

#define DPPerson \
struct _person \
{ \
char m_strName[16];\
int m_nAge; \
}*
现在我们有如下定义：TPPerson tp1,tp2; DPPerson dp1,dp2;
tp1 = tp2; dp1 = dp2;
上面第一条语句不会出错，没有任何问题。因为tp1,tp2都是对象指针，但是第二条语句就会出现问题，因为dp1是一个对象指针，而dp2是一个对象，这个宏隐藏的错误。
2）define SQUARE(X) (X)*(X)
这是求一个数的平方，但是在程序中如果有这样的语句：int x = 5,y; y = SQUARE(++x),这是一个逻辑错误又产生了。求得的实际值是42，而不是36。
3）字符串定义和标志粘贴
看看这两个宏定义：
#define TRACE(X) cout<< #X << " = " << X << endl;
#define MEMBER(A) char* A##_string;int A##_size
第一条可以打印出任何一个表达式的值，第二条可以把两个字符串合并成一个变量，看下面的例子：
#include
#define TRACE(X) cout<< #X << " = " << X << endl;
#define MEMBER(A) char* A##_string;int A##_size
using namespace std;

int main()
{
for(int i = 0;i < 10;i++)
TRACE((3+i));
MEMBER(one);
one_string = "Hello";
one_size = 4;
cout << one_string << ":" << one_size << endl;

return 0;
}
运行结果是：
(3+i) = 3
(3+i) = 4
(3+i) = 5
(3+i) = 6
(3+i) = 7
(3+i) = 8
(3+i) = 9
(3+i) = 10
(3+i) = 11
(3+i) = 12
Hello:4

史传红 2006-04-12 15:57 发表评论

C++ Thinking 学习笔记之一----变量的声明和定义

史传红 — Wed, 12 Apr 2006 07:55:00 GMT

变量的声明和定义的区别是：声明是向程序介绍一个名字，它指的是改名字是什么意思，在内存上并没有分配存储空间；而定义是指为这个名字分配存储空间。如在源文件example.c中的几个例子：
extern int i;//declaration without definition
extern int fun(void);//function declaration
float b;//declaration and definition
int fun(void)//definition
{
return 1;
}
int i;//definition
int add(int x)//declaration and definition
{
return x + 1;
}
void main()
{
b = 1.0f;
i = 2;
fun();
add(5);
}
extern int i; 指的是声明这个变量，在某个函数用到这个变量的时候，它会查找在该程序段中有没有
定义这个变量，如果没有，查找本模块的其他地方，之后查找整个全局空间。直到找到改变量的
定义，如果没有，程序出现编译错误。同样，如果在某个头文件定义了一个变量，例如：在example.h
头文件中定义了int x;如果有两个实现文件example1.c和example2.c都包含了该头文件，此时就会出现变量
重复定义错误。

史传红 2006-04-12 15:55 发表评论

实现（关于《[求助] 关于拷贝构造函数，对象传递！！》这篇文章）

史传红 — Wed, 12 Apr 2006 05:56:00 GMT

希望大家能够一起讨论，把矩阵这个类给完善。

#include
using namespace std;

class Matrix
{
private:
    int rows,columns;
    int **pMatrix;
public:
    Matrix(int rows = 3,int columns = 2);
    Matrix(const Matrix &M);
    ~Matrix();
    Matrix& operator=(const Matrix& M);
    int GetRows() const;
    int GetColumns() const;
    void SetValue();
    friend Matrix operator*(const Matrix& a,const Matrix& b);
    friend ostream& operator<<(ostream& os,const Matrix& M);
};

int Matrix::GetRows() const { return rows;}
int Matrix::GetColumns() const { return columns;}

// 构造函数
Matrix::Matrix(int x,int y)
{
    rows = x;
    columns = y;
    //有的时候为了考虑创建对象的效率，在使用的时候分配存储空间，而不在构造函数中分配
    pMatrix = new int* [x];
    for (int i = 0 ; i < x; i++ )
    {
        pMatrix[i] = new int[y];
        for(int j = 0;j < y;j++)   //初始化每个值为0
            pMatrix[i][j] = 0;
    }
}
// 析构函数
Matrix::~Matrix()
{
    for (int i = 0 ;i < rows;i ++ )
        delete[] pMatrix[i];
    delete[] pMatrix;
}

// 赋值函数
Matrix& Matrix::operator=(const Matrix& M)
{
if(this != &M)
{
  for (int ii = 0 ;ii < rows;ii++ )
   if(pMatrix[ii])
    delete[] pMatrix[ii];
  if(pMatrix)
   delete[] pMatrix;
    rows = M.rows;
    columns = M.columns;
  //分配存储空间
  pMatrix = new int* [rows];
  for (int k = 0 ; k < rows; k++ )
   pMatrix[k] = new int[columns];

  for ( int i = 0 ; i < rows; i ++ )
   for ( int j = 0 ; j < columns; j ++ )
    pMatrix[i][j] = M.pMatrix[i][j];
}
return *this;
}
void Matrix::SetValue()
{
int i,j,value;
for ( i = 0 ; i < rows; i ++ )
{
  for ( j = 0 ; j < columns; j ++ )
  {
   cout << " 第 " << i << " 行 " ;
   cout << " 第 " << j << " 列: " ;
   cin >> value;
   cout << endl;
   pMatrix[i][j] = value;
  }
}
}
// 拷贝构造函数
Matrix::Matrix(const Matrix& M)
{
rows = M.rows;
columns = M.columns;
//分配存储空间
pMatrix = new int* [rows];
for (int k = 0 ; k < rows; k++ )
  pMatrix[k] = new int[columns];

for ( int i = 0 ; i < rows; i ++ )
for ( int j = 0 ; j < columns; j ++ )
pMatrix[i][j] = M.pMatrix[i][j];
}

Matrix operator*(const Matrix& a,const Matrix& b)
{
if (a.columns == b.rows)
{
  Matrix c(a.rows,b.columns);
  for ( int i = 0 ;i < a.rows;i ++ )
  {
   for ( int j = 0 ;j < b.columns;j ++ )
   {
    for ( int columnIndex= 0 ;columnIndex < a.columns;columnIndex++ )
     c.pMatrix[i][j] += a.pMatrix[i][columnIndex] * b.pMatrix[columnIndex][j];
   }
  }
  return c;
}
else
  return Matrix();
}

ostream& operator<<(ostream& os,const Matrix& M)
{
for (int i = 0;i < M.rows;i++ )
{
  for (int j = 0;j < M.columns;j++ )
   os << M.pMatrix[i][j] << " ";
  os << endl;
}
return (os << endl);
}

// 主函数
void main()
{
Matrix Ma(3,2),Mb(2,2);
Ma.SetValue();
Mb.SetValue();
cout << Ma << endl;
cout << Mb << endl;

Matrix Mc = Ma * Mb;//拷贝构造函数
cout << Mc << endl;
Mc = Mb; //=运算符，即赋值函数
cout << Mb << endl;
}

史传红 2006-04-12 13:56 发表评论

关于C++模板函数的问题

史传红 — Tue, 11 Apr 2006 08:19:00 GMT

如下代码:
template
const T& max(const T& a,const T& b)
{
return a > b ? a : b;
}

int main()
{
const float f = max(1.5f,2.5f);
return 0;
}

这里const float f = max(1.5f,2.5f);这句怎么在编译的时候不能通过呢?我的平台是gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5),希望能够得到大家的帮助.

史传红 2006-04-11 16:19 发表评论

C++编程思想学习笔记－常量(转自一己薄剑)

史传红 — Tue, 04 Apr 2006 07:52:00 GMT

一、全局范围的const使用
1、const的使用有两种效果，一是生成编译期常量，二是运行期常量。
      做为编译期常量主要用作值替代，即取代C中的＃define常量定义，一般用于设置数组大小。
   此时不分配存储空间，只在有extern限定或取地址时才会分配空间。
      做为运行期常量主要控制程序的安全性，它们会被分配空间，但一经初始化就不能再改变，
   数组，结构等集合始终是运行期常量，不能当做编译期常量使用，例如不能用于设置数组大小。
   另外C中的const只是运行期常量。
2、const对指针的使用
   指向const的指针 const int* x，int const* x；
   const指针 int* const x；
   注意：关于赋值，不能把const指针（引用）赋给非const指针（引用）（会通过非const指针改
   变const指针指向的值！），但可以把非const指针（引用）赋给const指针（引用）。这是基于
   安全的考虑。
3、const用于函数参数与返回值
       参数做为const值一般作为函数中的一个初始值；但一般如下使用更易理解：
  void f(int ic)
  {
   const int& i=ic;
   //others
  }
    参数做为const指针或引用是基于安全与效率的原因；并且一般不改变参数的函数，参数要用
const int* cip或const int& ci;这样的函数可const和非const参数，若函数参数没有const
修饰则只能接受非const参数，不能接受const参数，不具有通用性，所以记住如下用法：
     void f(const int& ic)
     {}
注意：所有临时变量都是常量；
        返回值做为const值时表明此返回值不能做为左值或修改，一般用于用户自定义类，对于内部
    数据无意义。
        返回值做为const指针时要注意接受返回值的变量要为const所修饰。
二、类内部的const使用
1、类内部const的含义－它在每个类对象里分配存储空间，且一旦初始化后就不能改变（运行期常
   量），它要在构造函数的初始化表中初始化。
2、要想在类内部使用编译期常量，可以使用enum枚举；它不会占用存储空间。
3、const用于成员函数－表明此类函数不会改变对象的数据，能被const对象所调用（const对象只
   能调用const成员函数）但若想在const成员函数中改变数据，有两种方法：
   1>通过this指针把const变量强制转换为非const的。
   2>用mutable修饰要改变的变量。
   推荐使用2>。
三、volatile的使用
   表示此数据可以被改变－－用于编译器对此数据的优化假定，当编译器读取此数据时会认为它已
   被改变会再次读取到寄存器中，不会假定它没变从而直接使用寄存器的值。
   const volatile表示这个对象不能被程序员改变，但可以通过外面的工具改变（？不懂）。

史传红 2006-04-04 15:52 发表评论

对C++中友元的思考

史传红 — Mon, 03 Apr 2006 07:06:00 GMT

在C++中，如果以一个类想允许不属于当前类的成员函数访问该结构中的私有或保护数据时，那该怎么办呢？
这时可以用上friend这个关键字。例如：
class A;//Declaration

class B
{
public:
void fun(A *a);
};

class A
{
private:
int i;
public:
void initialize();
class D
{
private:
A *h;
public:
void initialize();
}
friend void g(A *a,int i);
friend void B::fun(A *a);
friend class C;
friend void h();
friend A::D;
};

void X::initialize()
{
i = 0;
}

void g(A *a,int i)//全局函数g直接访问了类A的私有成员
{
a->i = i;
}

void B::fun(A *a)//类B的成员函数直接访问了类A的私有成员
{
a->i = 47;
}

class C
{
private:
int j;
public:
void initialize()
void g(A *a);
};

void C::initialize()
{
j = 99;
}

void C::g(A *a)//类C的成员函数g直接访问了类A的私有成员
{
a->i = j;
}

void h()//全局函数h直接访问了类A的私有成员
{
A a;
a.i = 100;//
}

void A::D::initialize()//访问A的私有变量i
{
h->i = 10;
}

void main()
{
A a;
C c;
c.g(&a);
}

通过上面的例子，我们可以看到直接访问类A的私有成员i的方法。但是，由此我想到，
当我们发布我们自己的C++库的时候，比如我们有这样一个库（含有tools.h,tools.lib,tools.dll三个文件）
头文件定义：
class CTools
{
private:
int m_nId;
int m_nSize;
...
public:
...
};
我们的目的想让像m_nId,m_nSize这样的私有变量隐藏起来，但是有一个用户在使用我这个库的时候，
只要他用friend关键字稍作修改就可以直接访问我们的私有变量了。如下：
class CTools
{
    friend class CUser;
private:
    int m_nId;
    int m_nSize;
    ...
public:
    ...
};
这样的话，friend关键字是不是跟我们最初想把一些东西封装和隐藏起来相矛盾呢？

史传红 2006-04-03 15:06 发表评论

类的sizeof大小

史传红 — Mon, 03 Apr 2006 06:34:00 GMT

类的sizeof大小一般是类中的所有成员的sizeof大小之和，这个就不用多说。
不过有两点需要注意：1）当类中含有虚成员函数的时候，例如：
class B
{
float a;
public:
virtual void fun(void);
}
此时sizeof(B)的大小为8，而不是4。因为在类中隐藏了一个指针，该指针指向虚函数表，正因为如此，
使得C++能够支持多态，即在运行时绑定函数的地址。
2）另一个要注意的是，当类中没有任何成员变量，也没有虚函数的时候，该类的大小是多少呢？
例如：
class B2
{
void fun(void);
}
此时sizeof(B2)的值是多少呢？在C++早期的编译器中，这个值为0；然而当创建这样的对象时，
它们与紧接着它们后面的对象有相同的地址。比如：
B2 b2;
int a;
那么对象b2与变量a有相同的地址，这样的话对对象b2地址的操作就会影响变量a。所以在现在大多数编译器中，该值的大小为1。

史传红 2006-04-03 14:34 发表评论

何为仿函数(转自walkspeed)

史传红 — Sun, 02 Apr 2006 13:59:00 GMT

仿函数就是使对象使用行为看上去像个函数。
函数的使用是这样：
Function(param1,param2,...);
而对象的使用是这样：
Object.memberfunction(param1,param2...);
而仿函数对象的使用是这个样的
Object(param1,param2,...);
这样我们可以看出，从外表上看，仿函数对象和函数是一个东西。呵呵，当然他们是不同的。他们一样   不过是在使用的外形上一样罢了。

    一个仿函数类如下定义
    class ObjectFunction
    {
        .......
        public:
            返回的类型 operator() ([param1,param2,...]);
     };

     例1
     class ObjectFunction1
     {
          .......
          public:
              void operator() () { count << "No Param ObjectFuntion" << endl;
      };

      例2
      class ObjectFunction2
      {
           ........
           public:
               bool operator() (int x)
               {
                   count << "Have Param ObjectFuntion" << endl;
                   count << "This is ObjectFuntion's Param" << x << endl;

                   return true;
                }
         }

         仿函数的关键是要实现 operator() 运算符。

史传红 2006-04-02 21:59 发表评论

C/C++对字符的sizeof的处理

史传红 — Sun, 02 Apr 2006 13:17:00 GMT

在C中，sizeof('a')的输出值是4（32位编译器，如GCC）或者2（16位编译器，如TC）；在C++中，sizeof('a')的输出值是1，因为在C中，字符常量默认是一个int型的值，而在C++中它默认是一个char类型的值。为什么在C++中'a'被默认为char类型呢?我理解在C++中,有重载函数这个特性,例如:
void read(char var);
void read(int var);
如果我们调用这条语句:read('a');我们实际调用的是函数read(char var);然后如果C++中把'a'当成int类型来处理的话,这时候就会调用read(int var);这样的话就和我们的习惯不符.而在C中没有重载的概念,所以不会出现这样的情况.

史传红 2006-04-02 21:17 发表评论