C++博客-Dragon-随笔分类-C++

offset(type,member)的探讨

Dragon — Sat, 01 Jan 2011 03:00:00 GMT

这代码是参照别人的文章写的，只供自己理解用，有兴趣的也可以看看。
地址：http://eulertao.ycool.com/post.1762422.html
#include
#include
using namespace std;
#define offset(type,member) ((int)&(((type*)0)->member))
/*
即假设0地址是s类型的一个实例，则成员变量m的地址应该是？
应为起始地址是0，所以求出的地址也就可以直接看作是偏移量
*/
typedef void func(char *);

typedef struct mystu
{
char * str;
func * f;
}mystu_t;

void print(char * str)
{
printf("[%s]\n",str);
}

int main(int argc, char *argv[])
{
    mystu_t t;
    t.str="This is a expriment";
    t.f=print;
    int offs=offset(mystu_t,f);

    printf("&t=0x%x &t.f=0x%x offset=%d t.f=0x%x &print=0x%x\n",&t,&t.f,offs,t.f,&print);
    //t.f是函数在内存的实际地址，而&(t.f)是t中保存这个函数地址的地址。
    /*
      &t-------> -------------- 地址 -->0x22ff70 在我编译平台&t为:0x22ff70
                |   char*      |内容 -->"This is a expriment"
      &t.f-----> -------------- 地址 -->0x22ff74 在我编译平台&t.f为:0x22ff74
                |   func*      |内容 -->0x401390 是t.f(print)的实际地址,在我编译平台t.f为:0x401390
                 --------------
     */
    func * f1=*(func**)(((int)&t)+offs);//t+offs是t.f的地址,那就是func * 的地址，int起以转值的作用
    /*
      &t-----------------> -------------- 地址 -->0x22ff70 在我编译平台&t为:0x22ff70
                          |   char*      |内容 -->"This is a expriment"
      ((int)&t)+offs-----> -------------- 地址 -->0x22ff74 在我编译平台&t.f为:0x22ff74
                          |   func*      |内容 -->0x401390 是t.f(print)的实际地址,在我编译平台t.f为:0x401390
                           --------------
       可以看出 ((int)&t)+offs就是保存print地址的地址，但编译器不能直接用*对它取值，
       我们知道了它是print地址的地址后，就可以将它强制转换成func **,然后对它取值，就是func *
     */
    printf("real func addr = 0x%x\n", f1);
    f1(t.str);
    system("PAUSE");
    return EXIT_SUCCESS;
}
文件在这里，下载来看比较清楚：
代码文件

Dragon 2011-01-01 11:00 发表评论

Base64加密解密从Live555中提取(C++)

Dragon — Tue, 14 Dec 2010 06:10:00 GMT

摘要: /**//* *Base64Coder.h */#ifndef BASE64CODER_H#define BASE64CODER_H#include #ifdef __BORLANDC__#define Boolean bool#define False... 阅读全文

Dragon 2010-12-14 14:10 发表评论

成员函数指针是否用typedef的区别

Dragon — Thu, 02 Dec 2010 03:35:00 GMT

/*
*测试成员函数指针的小程序,有typedef与没有typedef的区别
*/
#include <iostream>
using namespace std;

class Test
{
public:
    Test();
    ~Test();

private:
    void add5(){ res+=5;}
    void add6(){ res+=6;}


    typedef void (Test::*add_5)();//现在add_5是一个类型了
    add_5 p_add_5;//p_add_5才是一个函数指针

    void (Test::*add_6)();//现在add_6是一个函数指针变量
public:
    void DoAddAction();
    void Display();
private:
    int res;
};

Test::Test()
{
    p_add_5=&Test::add5;//注意这里的写法
    add_6=&Test::add6;  //无论在类外还是类内，这个&都不能少
    res=0;
}

Test::~Test()
{

}

void Test::DoAddAction()
{
    (this->*p_add_5)();//使用类成员函数指针必须有“->*”或“.*”的调用
    (this->*add_6)();

}

void Test::Display()
{
    cout<<"The res is:"<<res<<endl;
}

int main()
{
    Test * test=new Test();
    test->DoAddAction();
    test->Display();
    delete test;
    return 0;
}

Dragon 2010-12-02 11:35 发表评论

成员函数指针数组

Dragon — Thu, 02 Dec 2010 03:04:00 GMT

/*
*测试成员函数指针数组的小程序
*/
#include <iostream>
using namespace std;

class Test
{
public:
    Test();
    ~Test();

private:
    void add5(){ res+=5;}
    void add6(){ res+=6;}

    void (Test::*add[2])();//这个2至关重要，在VC下没写会报错，但在QT里没报，但析构时出错！
public:
    void DoAddAction();
    void Display();
private:
    int res;
};

Test::Test()
{
    add[0]=&Test::add5;//注意这里的写法
    add[1]=&Test::add6;
    res=0;
}

Test::~Test()
{

}

void Test::DoAddAction()
{
    for (int i=0;i<2;i++)
    {
        (this->*add[i])();//使用类成员函数指针必须有“->*”或“.*”的调用
    }
}

void Test::Display()
{
    cout<<"The res is:"<<res<<endl;
}

int main()
{
    Test * test=new Test();
    test->DoAddAction();
    test->Display();
    delete test;
    return 0;
}

Dragon 2010-12-02 11:04 发表评论

动态创建的二维数组与二维数组

Dragon — Fri, 12 Dec 2008 15:26:00 GMT

动态创建的二维数组与二维数组:
先看看以下代码,是动太创建一个二维数组a[3][4]
        int **a;
    a=new int*[3];
    for(int i=0;i<3;i++)
    {
        a[i]=new int[4];
    }
这是我调试时剪下来的图:

前面三行是每行的首地址,分别是&a[0],&a[1],&a[2]
&a[0][0]到&a[0][3]是第一行元素的地址
&a[1][0]到&a[1][3]是第二行元素的地址

0x00372680-0x00372628=0x00000058
0x003726d8-0x00372680=0x00000058

可见,第一行和第二行,第二行和第三行相隔88(0x00000058)个字节
可以看出行与行之间是不连续的!

再看行里的:
0x0037262c-0x00372628=0x00000004
0x00372630-0x0037262c=0x00000004
0x00372634-0x00372630=0x00000004
都是相隔4(0x00000004)个字节,在我的电脑里整型是占4个字节.
可以看出行里是连续储存的!

再看我这代码(以第一行为例):

int a[3][4];

调试时剪下来的图:

图的说明与前面一样:

0x0012ff60-0x0012ff50=0x00000010
0x0012ff70-0x0012ff60=0x00000010

可见,第一行和第二行,第二行和第三行相隔16(0x00000010)个字节
一行有4个整型元素,一个4字节,刚好是16字节.
可见行与行之间是连续的!

你还可以从&a[0][3]与&a[1][0]相隔的字节数看出来!

0x0012ff60-0x0012ff5c=0x00000004

刚好第一行未接下来就是第二行的开始!

再看行里的(以第一行为例):

0x0012ff54-0x0012ff50=0x00000004
0x0012ff58-0x0012ff54=0x00000004
0x0012ff5c-0x0012ff58=0x00000004
可以看出行里也是连续储存的!

总结:
动态创建的二维数组的行与行之间的地址是不连续的,行里元素的地址是连续的!
而静态创建的二维数组的行与行之间的地址是连续的,行里元素的地址也是连续的!
所以用地址自增或地址+标号访问元素时要小心!

Dragon 2008-12-12 23:26 发表评论

void指针

Dragon — Tue, 02 Sep 2008 12:17:00 GMT

指针有两个属性:指向变量/对象的地址和长度
但是指针只存储地址,长度则取决于指针的类型
编译器根据指针的类型从指针指向的地址向后寻址
指针类型不同则寻址范围也不同,比如:
int*从指定地址向后寻找4字节作为变量的存储单元
double*从指定地址向后寻找8字节作为变量的存储单元

1.void指针是一种特别的指针
   void *vp
  //说它特别是因为它没有类型
  //或者说这个类型不能判断出指向对象的长度

2.任何指针都可以赋值给void指针
  type *p;
  vp=p;
  //不需转换
  //只获得变量/对象地址而不获得大小

3.void指针赋值给其他类型的指针时都要进行转换
   type *p=(type*)vp;
   //转换类型也就是获得指向变量/对象大小
转:http://icoding.spaces.live.com/blog/cns!209684E38D520BA6!130.entry

4.void指针不能复引用
  *vp//错误
  因为void指针只知道,指向变量/对象的起始地址
  而不知道指向变量/对象的大小(占几个字节)所以无法正确引用

5.void指针不能参与指针运算,除非进行转换
   (type*)vp++;
  //vp==vp+sizeof(type)

#include
#include
#include
using namespace std;
typedef struct tag_st
{
char id[10];
float fa[2];
}ST;
//我在程序里面这样使用的
int main()
{
ST * P=(ST *)malloc(sizeof(ST));
strcpy(P->id,"hello!");
P->fa[0]=1.1;
P->fa[1]=2.1;

ST * Q=(ST *)malloc(sizeof(ST));
strcpy(Q->id,"world!");
Q->fa[0]=3.1;
Q->fa[1]=4.1;
void ** plink=(void **)P;
*((ST *)(plink)) = * Q; //plink要先强制转换一下,目的是为了让它先知道要覆盖的大小.
                         //P的内容竟然给Q的内容覆盖掉了.
cout<id<<" "<fa[0]<<" "<fa[1]<return 0;
}

Dragon 2008-09-02 20:17 发表评论

数组形参

Dragon — Tue, 02 Sep 2008 12:15:00 GMT

写C++程序函数部分，传递数组往往已造成错误。总结一下
1，数组形参的定义。
如果要编写一个函数，输出int型数组的内容，可以用下面三种方式指定数组形参：
void printValues(int*)
void printValues(int[])
void printValues(int[10])
注意：不需要修改数组形参的元素时，函数应该将形参定义为指向const对象的指针
void f(const  int*)
2,多维数组的传递
除了第一维以外的所有维的长度都是元素类型的一部分，必须明确指定：
void printValues(int (*matrix)[10], int rowSize)
void printValues(int matrix[][10], int rowSize)//这个更直观.

//下面是例子
#include
using namespace std;
//一维数组形参
/*
void print(int *a)
{
cout<<*a<<" "<<*(a+1)<<" "<<*(a+2)<}
*/
/*
void print(int a[])
{
cout<<*a<<" "<<*(a+1)<<" "<<*(a+2)<}
*/
/*
void print(int a[3])
{
cout<<*a<<" "<<*(a+1)<<" "<<*(a+2)<}
*/
/*
void print(int a[3])
{
cout<}
*/
/*
void print(int *a)
{
cout<}
*/
/*
void print(int a[])
{
cout<}
*/
//上面哪一种都行
int main()
{
int a[3]={2,1,3};
print(a);
return 0;
}

//多维数组作形参
#include
using namespace std;
//三选一
//void print(int (*matrix)[3],int rowsize)
//void print(int matrix[2][3],int rowsize)
void print(int matrix[][3],int rowsize)
{
for(int i=0;i{
  for(int j=0;j<3;j++)
  {
   cout<  }
  cout<}
}
int main()
{
int a[2][3]=
{
  1,2,3,
  4,5,6
};
print(a,2);
return 0;
}

Dragon 2008-09-02 20:15 发表评论