伊人色综合久久天天,免费成人黄色av,久久国产婷婷国产香蕉

(�?C++�E�序调用C函数

Mon, 08 Mar 2010 07:23:00 GMT

转自�Q?a >http://blog.csdn.net/ustcgy/archive/2009/12/23/5063082.aspx

�q�种需求很�?又因为C++和C是两�U�完全不同的�~�译链接处理方式,所以要�E�加处理.�ȝ��大致有两大类实现�Ҏ��.

文中�l�出的是完整�?具体�?但又最基本最��单的实现,至于理论性的东西在网上很�Ҏ��搜烦的到.

一.通过处理被调用的C头文�?/strong>

a.h:

#ifndef __A_H
#define __A_H

#ifdef __cplusplus
extern "C" {
#endif

int ThisIsTest(int a, int b);

#ifdef __cplusplus
}
#endif

#endif

a.c:

#include "a.h"

int ThisIsTest(int a, int b) {
return (a + b);
}

aa.h:

class AA {
public:
      int bar(int a, int b);
};

aa.cpp:

#include "a.h"
#include "aa.h"
#include "stdio.h"

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

main.cpp:

#include "aa.h"

int main(int argc, char **argv){
int a = 1;
int b = 2;
AA* aa = new AA();
aa->bar(a, b);
delete(aa);
return(0);
}

Makefile:

all:
        gcc -Wall -c a.c -o a.o
        gcc -Wall -c aa.cpp -o aa.o
        gcc -Wall -c main.cpp -o main.o
        g++ -o test *.o

�? 通过处理调用的C++文�g

恢复a.h文�g��Z��般性C头文�?在aa.cpp文�g中extern包含a.h头文件或函数.

a.h:

#ifndef __A_H
#define __A_H
int ThisIsTest(int a, int b);
#endif

aa.cpp:

extern "C"
{
    #include "a.h"
}
#include "aa.h"
#include "stdio.h"

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

or

aa.cpp:

#include "aa.h"
#include "stdio.h"

extern "C"
{
    int ThisIsTest(int a, int b);
}

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

攀�?/a> 2010-03-08 15:23 发表评论

(�? �ȝ��C++中的所有强制�{换函�?const_cast�Q�reinterpret_cast�Q�static_cast�Q�dynamic_cast)

Mon, 22 Jun 2009 03:24:00 GMT
url: http://doserver.net/post/static_cast-const_cast-reinterpret_cast-dynamic_cast.php

非常抱歉�Q�谢谢郭老师的指正，我没有认真看�q�个文章��p�{�q�来了，其实他的错误太多了，而且�q�是致命的，对大家不负责��M��Q�请大家谅解�Q�现在是修正版本�Q�基本没有错误了�Q�如果觉得还有问题，误��p�L��Q�谢谢你的关注！
�q�篇文章其实�q�不是不才的原创�Q�本来打��自己写的，但是通过baidu一下，发现有兄弟写出来了，��干脆摘录下来，供大家参考��用了�Q?br>详情��L��Q?br>

view plain print ?

标准c++中主要有四种强制转换�c�d��q�算�W�：



const_cast�Q�reinterpret_cast�Q�static_cast�Q�dynamic_cast�{�等�?nbsp;









1�Q�static_cast(a)



��地址a转换成类型T�Q�T和a必须是指针、引用、算术类型或枚�D�c�d��?nbsp;



表达式static_cast(a), a的��D�{换�ؓ模板中指定的�c�d��T。在�q�行时�{换过�E�中�Q�不�q�行�c�d��查来��保转换的安全性�?nbsp;









例子�Q?nbsp;









class B { ... };



class D : public B { ... };



void f(B* pb, D* pd)



{



   D* pd2 = static_cast(pb);        // 不安�? pb可能只是B的指�?nbsp;









   B* pb2 = static_cast(pd);        // 安全�?nbsp;



   ...



}















class B { ... };



class D : public B { ... };



void f(B* pb, D* pd)



{



   D* pd2 = static_cast(pb);        // 不安�? pb可能只是B的指�?nbsp;









   B* pb2 = static_cast(pd);        // 安全�?nbsp;



   ...



}















class B { ... };



class D : public B { ... };



void f(B* pb, D* pd)



{



   D* pd2 = static_cast(pb);        // 不安�? pb可能只是B的指�?nbsp;









   B* pb2 = static_cast(pd);        // 安全�?nbsp;



   ...



}









2�Q�dynamic_cast(a)



完成�c�d��ơ结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表辑ּ��?nbsp;



表达式dynamic_cast(a) ��a��D�{换�ؓ�c�d��为T的对象指针。如果类型T不是a的某个基�c�d��Q�该操作��返回一个空指针�?nbsp;









例子�Q?nbsp;



class A { ... };



class B { ... };



void f()



{



  A* pa = new A;



  B* pb = new B;



  void* pv = dynamic_cast(pa);



  // pv 现在指向了一个类型�ؓA的对�?nbsp;



  ...



  pv = dynamic_cast(pb);



  // pv 现在指向了一个类型�ؓB的对�?nbsp;



}









3�Q�const_cast(a)



��L��c�d��中的帔R��Q�除了const或不�E�_��的变址敎ͼ�T和a必须是相同的�c�d��?nbsp;



表达式const_cast(a)被用于从一个类中去除以下这些属性：const, volatile, �?nbsp;__unaligned�?nbsp;









例子�Q?nbsp;















class A { ... };



void f()



{



const A *pa = new A;//const对象



A *pb;//非const对象









//pb = pa; // �q�里��出错，不能��const对象指针赋值给非const对象



pb = const_cast(pa); // 现在OK�?nbsp;



...



}















class A { ... };



void f()



{



const A *pa = new A;//const对象



A *pb;//非const对象









//pb = pa; // �q�里��出错，不能��const对象指针赋值给非const对象



pb = const_cast(pa); // 现在OK�?nbsp;



...



}















class A { ... };



void f()



{



const A *pa = new A;//const对象



A *pb;//非const对象









//pb = pa; // �q�里��出错，不能��const对象指针赋值给非const对象



pb = const_cast(pa); // 现在OK�?nbsp;



...



}









4�Q�reinterpret_cast(a)



��M��指针都可以�{换成其它�c�d��的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针�?nbsp;



表达式reinterpret_cast(a)能够用于诸如char* �?nbsp;int*�Q�或者One_class* �?nbsp;Unrelated_class*�{�类��D��L��转换�Q�因此可能是不安全的�?nbsp;









例子�Q?nbsp;



class A { ... };



class B { ... };



void f()



{



  A* pa = new A;



  void* pv = reinterpret_cast(pa);



  // pv 现在指向了一个类型�ؓB的对象，�q�可能是不安全的



  ...



}

攀�?/a> 2009-06-22 11:24 发表评论

可以�Ҏ��字符串创建类�?-解决�Ҏ�� 熟练c/c++(�?

Mon, 12 Jan 2009 14:29:00 GMT

想了很久�Q�结合c++设计新思维的方法，大家�q�种设计会有什么问题？

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�IShape.h�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br>class IShape
{
public:
IShape()
{
  printf("\n IShape\n");
}
virtual ~IShape()
{
  printf("\n ~IShape\n");
}
virtual void Draw() = 0;
};

typedef const char* ShapeType;
typedef IShape* (*Creator)();

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－ShapeFactory.h�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－

class ShapeFactory {
public:
    static ShapeFactory& Instance() {
        static ShapeFactory instance;
        return instance;
    }

    IShape* Create(ShapeType shapeType);
    bool RegisterShape(ShapeType shapeType, Creator creator);

private:
    ShapeFactory() {}
std::map shapeCreators;
};

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－ShapeFactory.cpp�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－

#include "CFactory.h"

IShape* ShapeFactory::Create(ShapeType shapeType) {
      Creator creator = shapeCreators.find( shapeType )->second;

      if ( creator == NULL )
      {
           return NULL;
       }
       return creator();
}

bool ShapeFactory::RegisterShape( ShapeType shapeType, Creator creator ) {
       map::iterator iter;
       iter = shapeCreators.find(shapeType);
       if(iter != shapeCreators.end())
       {
           return false;
       } else {
           shapeCreators[shapeType] = creator;
           return true;
    }
}

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－CCircle .h�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
#include

#include "IShape.h"
#include "CFactory.h"
class CCircle : public IShape
{
public:
CCircle()
{
  printf("\n CCircle\n");
}
virtual ~CCircle()
{
  printf("\n ~CCircle\n");
}

virtual void Draw();
};

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－CCircle .cpp�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
#include "CCircle.h"

IShape* Create() { return new CCircle(); }
static const bool RegisterShape__ = ShapeFactory::Instance().RegisterShape( "CCircle", Create);

void CCircle::Draw()
{
printf("\n CCircle::Draw\n");
}

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－main.cpp�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
#include
#include"CFactory.h"

#include "IShape.h"

int main() {
    IShape* line = ShapeFactory::Instance().Create("CCircle");
    line->Draw();
    return 0;
}

有点��小的兴奋，大家�U�极发言哟！�Q�！

主要参考： http://blog.csdn.net/jicao/archive/2006/07/01/861343.aspx
                     http://blog.csdn.net/hjsunj/archive/2008/01/07/2028597.aspx
                     《c++设计新思维�?/p>

攀�?/a> 2009-01-12 22:29 发表评论

C语言怎么解析声明熟练c/c++(�?

Thu, 08 Jan 2009 13:09:00 GMT

         首先声明如果�?/span>�?/span>int (*a)[10], char* const (*next());�?/span>�l�了解，��׃��要看了，一个声明是没什么意思的�Q�这��文章只是想阐述�?/span>C语言是怎么解析它的声明�?/span>

         声明里面可以包括的元素有�Q?/span>�c�d��说明�W?/span>(int, void, char,struct...)�Q�存储类�?/span>extern, static, register, �c�d��限定�W?/span>(const, volatile), 变量�?/span>(标识�W?/span>), �W�号(*�Q?/span>圆括号和中括�?/span>)�Q?/span>

       ��M��原则是，扑ֈ�标识�W?/span>(��x��?/span>们��^时叫的变量名)�Q�从叛_��左解析；

       具体�?/span>骤如下：

       1. 扑ֈ�声明中最�?/span>边的标识�W?/span>,��L��标识�W?/span>   => 变量是叫“标识�W?/span>”

       2. 查看标识�W�右边的下一个符�?/span>�Q?/span>如果是方括号�Q�取出可能的大小�Q�去掉方括号 �Q?/span>>是一个数�l?/span>�?/span>

    3. 查看标识�W�右边的下一个符�?/span>�Q?/span>

如果是左圆括��P��取出可能的参敎ͼ�一直到��x��?/span> �Q?/span>> 是一个函�?/span>

       4. 查看标识�W�左边的�W�号�Q?/span>如果是左括号�Q�找�?/span>对应的右括号�Q��ƈ把括号中的声明组合在一�?/span>。回到第2步重新开始执行�?/span>

       5. 查看标识�W�左边的�W�号�Q?/span>如果�?/span>const, volatile,*, �l�箋向左�ȝ��C��是这三个�c�d��为止�?/span>重复�W?span>4步�? =>�?/span>释�ؓconst, volatile,指向什么的指针

       6. 剩下的符号一�q?/span>��d�� =>static unsigned int

       你可能想问这几步��可以解决了? 是的�Q�这��是所谓的��奇解码环�?/span>

    下面我来随便验证下这个算�?span>:

       先来个简单的

int (*a)[10] �?int* a[10];

   声明�?span>      步骤               执行�l�果

int (*a)[10]    �W?span>1�?nbsp;          扑ֈ�最左边的标识符a�Q�表�C?span>a是一�?span>…

int (*)[10]      �W?span>2�Q?span>3�?span>    不匹�?/span>

int (*)[10]      �W?span>4�?span>          匚w��(,直接��d��),包括*�Q�表�C?span>a是一个指�?span>…指针.Step2

int [10]          �W?span>2�?span>           匚w��[10]�Q�表�C?span>a是一个指�?span>..size=10的数�l�的指针

int                 �W?span>3�Q?span>4�Q?span>5    不匹�?/span>

�l�束            �W?span>6�?span>           表示a是一个指�?span>int数组的指�?/span>

int* a[10]     �W?span>1�?span>           a是一�?/span>

int* [10]       �W?span>2�?span>           a是一�?span>…size=10的数�l?/span>

int*              �W?span>3�?span>           不匹�?/span>

int                �W?span>4�?span>           匚w��Q?span>a是一个存攄��指针�Q?span>size=10的数�l?/span>

int                �W?span>5�?span>           匚w��Q?span>a是一个存攄��int指针�Q?span>size=10的数�l?/span>

       大家�?/span>的出两个声明的结果是一个是指针�Q�一个是数组�?/span>

    int a1[10];

    int a2[20];

    int (*b)[10];

    int* c[10];

    a[0] = 10;

    b = &a2;    //报错�Q?/span>cannot convert from 'int (*)[20]' to 'int (*)[10]'

    b = &a1;    //b是指�?/span>size=10的数�l�的指针

    c[0] = &a1[0]; //c是一个数�l�，里面存放的是指针�Q�指针指�?/span>int;

�Q�未完待�l�）

攀�?/a> 2009-01-08 21:09 发表评论

�l�构体对齐那点事熟练c/c++(�?

Tue, 06 Jan 2009 15:39:00 GMT

          刚刚完成一个文件的�q�移�E�序�Q�其中遇��C��l�构体对齐的问题�Q�所以拿出来说说�Q�与各位博友们分享�?/span>

我的�E�序很简单，��是把之前通过一个结构体fwrite到文�?/span>A里的内容��d��Q�然后�{�l�另一个结构体保存。程序是��单，但我担心的是之前�?/strong>�l�构�?/span>fwrite到文�?/span>A的程序对齐结构体规则是怎样的？一定要知道它吗? 当然了，如果那个�E�序�l�构体是按照1寚w��写入的，我的�E�序�l�构体是按照4寚w��d��Q�那不就�p�了�Q?/span>

      �q�里我引入结构体寚w��的概念，也可以说是内存对齐了。�ؓ什么要内存寚w��呢，��是方便CPU��d��了，具体原因大家要参考计��机体系�l�构了。先看一个内存对齐的例子�Q?/span>

      struct example1{

           char a;

           double b;

           long l;

};

      struct example2{

           char a;

           long l;

           double b;

};

大家��算�l�构体大��，初次接触的博友可能对�{�案有点惊讶�Q?/span>VC�~�译�Q?/span> sizeof后结果分别是�Q?/span>24�Q?/span>16�?/span> 同样是的�l�构体，成员换了��序�Q�大��就不同了。其实内存对齐有个规则，只要知道了，��?/span>OK。那么以�?/span>5�Ҏ��关键

1�Q?span>          内存寚w��与编译器讄��有关�Q�首先要搞清�~�译器这个默认值是多少

2�Q?span>          如果不想�~�译器默认的话，可以通过#pragma pack(n)来指定按�?/span>n寚w��

3�Q?span>          每个�l�构体变量对齐，如果寚w��参数n(�~�译器默认或者通过pragma指定)大于该变量所占字节数(m)�Q�那么就按照m寚w��Q�内存偏�U�d��的地址�?/span>m的倍数�Q�否则是按照n寚w��Q�内存偏�U�d��的地址�?/span>n的倍数。也��是最��化长度规则

4�Q?span>          �l�构体��d��?/span>: 寚w��后的长度必须是成员中最大的寚w��参数的整数倍。最大对齐参数是从第三步得到的�?/span>

5�Q?span>          补充�Q�如果结构体A中还要结构体B�Q�那�?/span>B的对齐方式是选它里面最长的成员的对齐方�?/span>

所以计��结构体大小要走三步�Q�首先确定是当前�E�序按照几对�?/span>(参照1�Q?/span>2�?/span>)�Q�接着计算每个�l�构体变量的大小和偏�U?/span>(参照3�Q?/span>5)�Q�最后计��结构体��d��（参照4�Q��?/span>

      先算��?/span>example1吧，假设�~�译器是�?/span>16寚w��?/span>

      1�Q�确定按照几寚w��: 16;

      2�Q�确定每个成员的偏移�Q?/span>a 占一个字节，16>1, 按照1寚w��Q��v始位�|?/span>0�Q?/span>0%1 = 0�Q�那�?/span>a��存�?/span>0位置�Q?/span>b�?/span>8个字节，16>8�Q�按�?/span>8寚w��Q��v始位�|�就不能�?/span>1了，因�ؓ要按�?/span>8寚w��Q�所以最�q�的偏移起始位置�?/span>8�Q?/span> 8%8 =0, 那么b��存在位�|?/span>8-15的位�|�；l�?/span>4个字节，16>4�Q�按�?/span>4寚w��Q��v始位�|?/span>16�Q?/span> 16%4=0�Q�那�?/span>l��存在位�|?/span>16-19的位�|�。所以结构体�?/span>0�?/span>19一共占�?/span>20个字�?/span>

      3�Q�结构体��d��：成员中最大的寚w��参数�?/span>b�?/span>8寚w��Q�所�?/span>20�Q?/span>8!=0, 24刚好�?/span>

      真的很搞�Q�同理计��?/span>example2应该�?/span>16�Q?/span>

     再�D个结构体嵌套的例子吧�Q?/span>

#pragma pack(push)

#pragma pack(8)

struct test1{

      int a;

      char b;

      int c[20]

long l;

} ;

struct test2{

      char a1;

      char a2;

      struct test1 t1;

      double b1;

}

#pragma pack(pop)

先计��?/span>test1, 8寚w��Q?/span>a占用0-3�Q?/span>b占用4�Q?/span>c占用8�Q?/span>87�Q?/span>l占用88�Q?/span>91�Q�一�?/span>92个字节。成员中最大的寚w��参数�?/span>int�?/span>92%4=0;

再计��?/span>test2, a1z占用0�Q?/span>a2占用1�Q?/span>t1呢，4 % 4 (test1里面最长的成员的对齐方�? = 0, 4-95�Q?/span>b1�?/span>96�?/span>103�Q�一�?/span>104个字节，成员中最大的寚w��参数�?/span>double�?/span>104%8=0; 所以是104.

      那关于我文章开头提到的那个文�g转换�Q�我现在只要知道原始�E�序是按照什么对齐的�Q�然后在新程序中指定按照几对齐就可以了，哈哈�Q?nbsp;

      挤时间写的，有的地方有遗漏，请各位指正！

攀�?/a> 2009-01-06 23:39 发表评论

public�l�承后，父类与子�c�访问隐�?熟练c/c++(�?

Mon, 05 Jan 2009 03:16:00 GMT

         《Effective C++》的�W�六章节�l�承与面向对象设计花了大部分的篇�q�在介绍�l�承遮掩(Hiding Inherited Name)�Q�那我也效仿下大师，做个��的�ȝ��?br>         public�l�承的目的是要徏立父子类的is-a关系�Q�也��是说用到父�cȝ��地方�Q�在子类一定能用。现实的代码�~�写中，我们主要也是用public�l�承�Q�所以每个�h都有自己一套��承的写法和调用，直到看到Effecitve C++�Ӟ��才会发现�q�有很多其它的用法，在这里我�q�不鼓励大家��试各种写法�Q�毕竟代码要�E�_��Q�我只是��x��一些可能的形式表现出来�Q�供大家参考�?br>class Base
{
public:
       virtual void fn() = 0;
       virtual void fn(int i){printf("\n Base: fn(int)\n");};
       virtual void fn2() {printf("\n Base: void fn2(int)\n");}
       void fn3() {printf("\n Base: fn3()\n");}
       void fn4(){printf("\n Base: fn4()\n");}
};

class ClassA : public Base
{
public:
      ClassA(int n, int d);
      // using Base::fn2;
      virtual void fn(){printf("\n ClassA: fn()\n");};
       virtual void fn(int i){printf("\n ClassA: fn(INT)\n");};

       virtual void fn2(int i) {printf("\n ClassA: fn2(INT)\n"); }

       void fn3() {printf("\n ClassA: fn3()\n");}
       void fn4(int i){printf("\n ClassA: fn4()\n");}
};
int main()
{
Base* pBase1 = new ClassA(10, 20);
pBase1->fn();              //OK�Q�ClassA: fn()
pBase1->fn(11);          //OK�Q�ClassA: fn(INT)
pBase1->fn2();            //OK�Q�Base: void fn2(int)
pBase1->fn2(2);          //NO, 不能讉K��
pBase1->fn3();            //OK�Q�Base: fn3()
pBase1->fn4();            //OK�Q�Base: fn4()
pBase1->fn4(2);          //NO�Q�不能访�?br> printf("\n============================================\n");
ClassA* pDerived = new ClassA(10, 20);
pDerived->fn();            //OK�Q�ClassA: fn()
pDerived->fn(1);          //OK�Q�ClassA: fn(INT)
pDerived->fn2();          //NO�Q�不能访�?br> pDerived->fn2(2);        //OK�Q�ClassA: fn2(INT)
pDerived->fn3();          //OK�Q�ClassA: fn3()
pDerived->fn4();          //NO�Q�不能访�?br> pDerived->fn4(2);        //NO�Q�ClassA: fn4(INT)
printf("\n============================================\n");
return 0;
}

子类父类同名virtual函数(参数相同)�Q?用子�cȝ��指针�Q�引用，对象讉K��Ӟ��子类会覆盖父�c�L��?只能讉K��子类�Ҏ��)�?br>子类父类同名virtual函数(参数相同)�Q?用父�cȝ��指针�Q�引用，对象讉K��Ӟ��子类会覆盖父�c�L��?只能讉K��子类�Ҏ��)�?br>子类父类同名virtual函数(参数不同)�Q?用子�cȝ��指针�Q�引用，对象讉K��Ӟ��子类会覆盖父�c�L��?只能讉K��子类�Ҏ��)�?br>子类父类同名virtual函数(参数不同)�Q?用父�cȝ��指针�Q�引用，对象讉K��Ӟ��父类会覆盖子�c�L��?只能讉K��父类�Ҏ��)�?br>子类父类同名virtual函数(函数�c�d��不同const/non-const)�Q?用子�cȝ��指针�Q�引用，对象讉K��Ӟ��子类会覆盖父�c�L��?只能讉K��子类�Ҏ��)�?br>子类父类同名virtual函数(函数�c�d��不同const/non-const)�Q?用父�cȝ��指针�Q�引用，对象讉K��Ӟ��父类会覆盖子�c�L��?只能讉K��父类�Ҏ��)�?/p>
�l�论�Q�参数和函数�c�d��是c++�~�译器判断要不要多态的关键因素。注: �q�回�c�d��不同�Ӟ��~�译器会报错�Q�virtual不能和static�q�用。静态成员函敎ͼ�没有隐藏的this指针�Q�virtual函数一定要通过对象来调用，既要this指针�?br>改进:�Q�如果子�c�L��针想讉K��到父�c�，可以在子�c�里加入:using 父类�?:函数名；如pDerived->fn2(); 讉K��父类�Ҏ��Q�在ClassA里面加入using Base::fn2�Q�就可以讉K��了。如果父�c�L��针想讉K��到子�c�，��需要指针�{换了�?br>
子类父类同名non-virtual函数(无论参数/�q�回/函数�c�d��(const或static))�Q�用子类的指针，引用�Q�对象访问，子类会覆盖父�c�L��?只能讉K��子类�Ҏ��)�?br>子类父类同名non-virtual函数(无论参数/�q�回/函数�c�d��(const或static))�Q�用父类的指针，引用�Q�对象访问，父类会覆盖子�c�L��?只能讉K��父类�Ҏ��)�?br>
�l�论: non-virtual函数�Q�既没有��M��多态效果，如果父类要访问子�c�，只用指针转换�?nbsp;

         所谓大道至��Q�想必大家看着�q�个都烦�Q�我也是。想了想应该�q�样表达最��单：

         子类public�l�承父类的函敎ͼ�唯有满��(参数�Q�返回��|��函数�c�d��相同&父类是virtual)函数�Q�父�cȝ��指针�Q�引�?也指针实现的)能够多态的讉K��子类�Q�否则父�c�L��针只能访问父�cȝ��Ҏ��?nbsp;

         子类public�l�承父类的函敎ͼ�子类的方法名会遮掩父�cȝ��相同名的�Ҏ��。子�c�要惌��问父�cȝ��Ҏ��Q��用using 父类�?:函数名�?nbsp;

         具体的原因我觉得可能�q�是得找旉��拜读下候杰译的《C++对象模型》，看看到底�q�个东西是怎么设计的�?br>

攀�?/a> 2009-01-05 11:16 发表评论

Thu, 18 Dec 2008 03:15:00 GMT
在过�ȝ��学习中，我们始终接触的单个类的��承，但是在现实生�z�M��Q�一些新事物往往会拥有两个或者两个以上事物的属性，��Z��解决�q�个问题�Q�C++引入了多重��承的概念�Q?font color=#ff0000>C++允许��Z��个派生类指定多个基类�Q�这��L��l�承�l�构被称做多重��?/strong>�?
　　举个例子�Q�交通工��L��可以�z��出汽车和船两个子�c�，但拥有汽车和船共同特性水陆两用汽车就必须�l�承来自汽�R�c�M��船类的共同属性�?

　　由此我们不难惛_��如下的图例与代码�Q?/p>

　当一个派生类要��用多重��承的时候，必须在派生类名和冒号之后列出所有基�cȝ��c�d��Q��ƈ用逗好分隔�?/font>



#include <iostream>
using namespace std;

class Vehicle
{
    public:
        Vehicle(int weight = 0)
        {
            Vehicle::weight = weight;
        }
        void SetWeight(int weight)
        {
            cout<<"重新讄��重量"<            Vehicle::weight = weight;
        }
        virtual void ShowMe() = 0;
    protected:
        int weight;
};
class Car:public Vehicle//汽�R
{
    public:
        Car(int weight=0,int aird=0):Vehicle(weight)
        {
            Car::aird = aird;
        }
        void ShowMe()
        {
            cout<<"我是汽�R�Q?<        }
    protected:
        int aird;
};

class Boat:public Vehicle//�?nbsp;
{
    public:
        Boat(int weight=0,float tonnage=0):Vehicle(weight)
        {
            Boat::tonnage = tonnage;
        }
        void ShowMe()
        {
            cout<<"我是船！"<        }
    protected:
        float tonnage;
};

class AmphibianCar:public Car,public Boat//水陆两用汽�R,多重�l�承的体�?nbsp;
{
    public:
        AmphibianCar(int weight,int aird,float tonnage)
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)
        //多重�l�承要注意调用基�c�L��造函�?nbsp;
        {

        }
        void ShowMe()
        {
            cout<<"我是水陆两用汽�R�Q?<        }
};
int main()
{
    AmphibianCar a(4,200,1.35f);//错误
    a.SetWeight(3);//错误
    system("pause");
}

　　上面的代码从表面看，看不出有明显的语发错误，但是它是不能够通过�~�译的。这有是��Z��么呢�Q?
　　�q�是�׃��多重�l�承带来�?font color=#ff0000>�l�承的模�p��?/font>带来的问题�?/p>
　先看如下的图�C�：

　　在图中深�U�色标记出来的地�Ҏ��是主要问题所在，水陆两用汽�R�cȝ��承了来自Car�c�M��Boat�cȝ��属性与�Ҏ��Q�Car�c�M��Boat�c�d��为AmphibianCar�cȝ��基类�Q�在内存分配上AmphibianCar获得了来自两个类的SetWeight()成员函数�Q�当我们调用a.SetWeight(3)的时候计��机不知道如何选择分别属于两个基类的被重复拥有了的�c�L��员函数SetWeight()�?

　　�׃��q�种模糊问题的存在同样也��D��了AmphibianCar a(4,200,1.35f);执行��p�|�Q�系�l�会产生Vehicle”不是基或成员的错误�?/p>
　　以上面的代码��Z��Q�我们要惌��AmphibianCar�c�L��获得一个Vehicle的拷贝，而且又同时共享用Car�c�M��Boat�cȝ��数据成员与成员函数就必须通过C++所提供�?font color=#ff0000>虚拟�l�承技术来实现�?/p>
　　我们在Car�c�d��Boat�cȝ��承Vehicle�c�d��Q�在前面加上virtual关键字就可以实现虚拟�l�承�Q��用虚拟��承后�Q?font style="BACKGROUND-COLOR: #b000b0" color=#ffffff>当系�l�碰到多重��承的时候就会自动先加入一个Vehicle的拷贝，当再�ơ请求一个Vehicle的拷贝的时候就会被忽略�Q�保证��承类成员函数的唯一�?/font>�?

　　修改后的代码如下�Q�注意观察变化：

#include <iostream>
using namespace std;

class Vehicle
{
    public:
        Vehicle(int weight = 0)
        {
            Vehicle::weight = weight;
            cout<<"载入Vehicle�c�L��造函�?<        }
        void SetWeight(int weight)
        {
            cout<<"重新讄��重量"<            Vehicle::weight = weight;
        }
        virtual void ShowMe() = 0;
    protected:
        int weight;
};
class Car:virtual public Vehicle//汽�R�Q�这里是虚拟�l�承
{
    public:
        Car(int weight=0,int aird=0):Vehicle(weight)
        {
            Car::aird = aird;
            cout<<"载入Car�c�L��造函�?<        }
        void ShowMe()
        {
            cout<<"我是汽�R�Q?<        }
    protected:
        int aird;
};

class Boat:virtual public Vehicle//�?�q�里是虚拟��?nbsp;
{
    public:
        Boat(int weight=0,float tonnage=0):Vehicle(weight)
        {
            Boat::tonnage = tonnage;
            cout<<"载入Boat�c�L��造函�?<        }
        void ShowMe()
        {
            cout<<"我是船！"<        }
    protected:
        float tonnage;
};

class AmphibianCar:public Car,public Boat//水陆两用汽�R,多重�l�承的体�?nbsp;
{
    public:
        AmphibianCar(int weight,int aird,float tonnage)
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)
        //多重�l�承要注意调用基�c�L��造函�?nbsp;
        {
            cout<<"载入AmphibianCar�c�L��造函�?<        }
        void ShowMe()
        {
            cout<<"我是水陆两用汽�R�Q?<        }
        void ShowMembers()
        {
            cout<<"重量�Q?<        }
};
int main()
{
    AmphibianCar a(4,200,1.35f);
    a.ShowMe();
    a.ShowMembers();
    a.SetWeight(3);
    a.ShowMembers();
    system("pause");
}

　　注意观察�c�L��造函数的构造顺序�?

　　虽然说虚拟��承与虚函数有一定相似的地方�Q�但读者务必要��C��Q�他们之间是�l�对没有��M��联系的！

攀�?/a> 2008-12-18 11:15 发表评论

C++怎么实现AOP

Fri, 14 Dec 2007 06:02:00 GMT

            AOP技术的诞生�q�不��晚�Q�早�?990�q�开始，来自Xerox Palo Alto Research Lab�Q�即PARC�Q�的研究人员��对面向对象思想的局限性进行了分析。他们研�I�出了一�U�新的编�E�思想�Q�借助�q�一思想或许可以通过减少代码重复模块从而帮助开发�h员提高工作效率。随着研究的逐渐深入�Q�AOP也逐渐发展成一套完整的�E�序设计思想�Q�各�U�应用AOP的技术也应运而生�?/p>
            AOP技术在Java�q�_��下是最先得到应用的。就在PARC对于面向斚w��~�程�q�行研究的同�Ӟ��国Northeastern University的博士生Cristina Lopes和其同事也开始了�c�M��的思考。最�l�，��国国防先进技术研�I�计划��v�Q�Defense Advanced Research Projects Agency即DARPA�Q�注意到了这��工作，�q�提供了�U�研�l�费�Q�鼓励将二者的工作成果�l�合��h��。他们通过定义一套Java语言的扩展系�l�，使开发者可以方便的�q�行面向斚w��的开发，�q�套扩展�pȝ��被称为AspectJ。之后，AspectJ�?002�q�被转让�l�Eclipse Foundation�Q�从而成为在开源社��Z��AOP技术的先锋�Q�也是目前最为流行的AOP工具�?br>
            那么对于C++技术来��_��怎样来开展AOP呢，�q�好有Olaf Spinczyk �q�样的�h存在�Q�我们也有了aspect c++。它使用了插入代码的�Ҏ��。一个典型的Aspect C++�C�Z��需要一个C++源文�?.cpp)、一个aspect C++源文�?.ah)�Q�通过ac++�~�译器把C++源文件和aspect C++源文件�{换成混合的C++源文�?如果有头文�g也会转换)�Q�最后通过普通的C++�~�译器编译出可执行文件�?br>
            那么我现在如果不想用�W�三方编译器�Q�自己去实现AOP�Q�不知道CPPBLOG里的大虾有什么想法？

攀�?/a> 2007-12-14 14:02 发表评论

Thu, 11 Oct 2007 13:09:00 GMT
     摘要: const关键字可以说是用途广泛，从对变量的限定到对函数的限定�Q�尤其是那个指向帔R��的指针（const int *p�Q�，指针帔R��(int * const p)�Q�指向常量的指针帔R��(const int* const p)更让初学者摸不到头脑。这里我主要��x��q�C��最�q�项目中关于const的一个问题。其实有的时候还不能被表面现象迷惑了�Q�简单代码如�?nbsp; 阅读全文

攀�?/a> 2007-10-11 21:09 发表评论

�q�回内部静态成�? 熟练C/C++�Q�一�Q?

Fri, 13 Apr 2007 08:07:00 GMT

        看完陈皓�?/span>C/C++�q�回内部静态成员的陷阱�Q�认识到自己��实�?/span>C/C++本��n语法研究的不够清楚，所以这些时间就在对基本知识�q�行回顾�Q�真的还蛮有意思的�?/span>

        我在�?/span>C/C++函数�Ӟ��从没有全面考虑�q�该函数功能�Q�只是知道它能做�Q�基本对函数�l�节没有了解�Q�就拿下面这个函数做个例子：

        char *inet_ntoa(struct in_addr in);

        struct in_addr {      unsigned long int s_addr; }

        看到�q�个我就能想到该函数是把一�?/span>unsigned long type的数转换成一个字�W�串。其它什么都不想。现在让我们来仔�l�品读里面的东西�?/span>

        我传入一�?/span>unsigned long type的数据，它给我传��Z��?/span>char *�Q�那�q�个char * 在函数里怎么分配�I�间的。首先不可能是堆分配�Q�因为如果是那样的话�Q�你用完�q�个函数后还要释放资源。其�ơ不可能是栈分配�Q�因为那样函数返回后栈也会跟着释放。那�q�有可能是全局变量�Q�如果这��L��话，C/C++中已�l�有好多全局了。那�q�有一�U�是static的可能，static不会随着函数的返回而释放，也就是说�Q�它是一块长期被分配的内存空��_��现在在假若我在程序中�q�样写：

        printf(“%s, %s”, inet_ntoa(a), inet_ntoa(b)); //a, b 是两个不相等的�?/span>

        输出会让我大吃一惊，输出�l�果一栗��原因很��单，��是printf先求b�Q�把值给了那�?/span>static�Q�然后再�?/span>a, 把值又�l�了static�Q?/span>static的那块内存最�l�被写入�?/span>a的��|��q�个时候输出，那当然就输出的同一个��g��。还有一�U�错误写法，如下�Q?/span>

        Char *tmp1 = inet_ntoa(a);

        Char *tmp2 = inet_ntoa(b);

        �q�样也是有问题的�Q�因�?/span>tmp1�?/span>tmp2都指向了一块内存，当前�?/span>static的值就�?/span>b的��g��。所以�ȝ��如下�Q��用这�U�函��C��定要copy函数�q�回的��|��而不能去保存其内存地址�Q?br>附inet_ntoa()源码�Q?br>#include
#include
#include
#include

/* The interface of this function is completely stupid, it requires a
   static buffer. We relax this a bit in that we allow at least one
   buffer for each thread. */

/* This is the key for the thread specific memory. */
static __libc_key_t key;

/* If nonzero the key allocation failed and we should better use a
   static buffer than fail. */
static char local_buf[18];
static char *static_buf;                                //静�?/span>

/* Destructor for the thread-specific data. */
static void init (void);
static void free_key_mem (void *mem);

char *
inet_ntoa (struct in_addr in)
{
__libc_once_define (static, once);
char *buffer;
unsigned char *bytes;

/* If we have not yet initialized the buffer do it now. */
__libc_once (once, init);

if (static_buf != NULL)
    buffer = static_buf;
else
    {
      /* We don't use the static buffer and so we have a key. Use it
to get the thread-specific buffer. */
      buffer = __libc_getspecific (key);
      if (buffer == NULL)
{
/* No buffer allocated so far. */
buffer = malloc (18);
if (buffer == NULL)
    /* No more memory available. We use the static buffer. */
    buffer = local_buf;
else
    __libc_setspecific (key, buffer);
}
    }

bytes = (unsigned char *) ∈
__snprintf (buffer, 18, "%d.%d.%d.%d",
      bytes[0], bytes[1], bytes[2], bytes[3]);

return buffer;
}

/* Initialize buffer. */
static void
init (void)
{
if (__libc_key_create (&key, free_key_mem))
    /* Creating the key failed. This means something really went
       wrong. In any case use a static buffer which is better than
       nothing. */
    static_buf = local_buf;
}

攀�?/a> 2007-04-13 16:07 发表评论

心情不错

Wed, 28 Mar 2007 11:52:00 GMT

�l�过一些时候项目中�?/span> C++ 的��用，我算是有一�?/span> C++ 的项目经验，但是反过来说�Q�我只是写些基本的程序，没有深入到构�Ӟ��主要�q�是�?/span> C 的思想�Q�昨天写 struct �Ӟ��我发现在 C �?/span> C++ 中写法是不是��L��?/span>

C �Q?/span>

struct Node{              // 声明

       int node;

       struct Node *next;        // 定义

};

struct Node list;

或�?/span>

typedef Node {

   int node;

   struct Node *next;

}ListLink;

ListLink list;

C++:

struct Node{

    Int node;

    Node *next;

};

Node list;               // 搞定�?/span>

�q�样一�?/span> C++ 的确实在代码的层面上��单了�Q�但理解��h��却不是很舒服�Q?/span>

今天刚接��C�Q务做 Wireless-Lan �Q�好长时间没做正事了�Q�这两天主要在写文档�Q�东西还比较多，但是和我一�l�的 Danel人很�?/span> �Q�给我讲了下整个 class diagram 的流�E�，虽没�?/span> sequence 那么�Ҏ��理解�Q�但我还是懂了。而且我发��C��写程序时特别开心，心态很好，�q�也是我在追求的�Q�慢慢来吧。�ȝ��说这周五之前做出点东西，呵呵�Q�不能让他失望呀�Q�过会再看看代码�Q?/span> GUI �Q�我蛮喜�Ƣ写的�?/span>

再说说今天用的那个工��P�� SOURCE INSIGHT �Q�真爽。看代码的强有力工具。下�ơ给 PASSION 的兄弟们介绍下�?/span>

攀�?/a> 2007-03-28 19:52 发表评论

Sun, 31 Dec 2006 08:00:00 GMT

C的实现都是有两个不同的环境：��译与执�?br>
��译�Q?br>

把多个源文�g�~�译成目标代码。编译分为预处理�?把类��g��#define的替换源文�g)�Q�然后解析，也就是来识别代码�Q�大多数错误和警告��生在�q�步�Q�最后目标代码便生成。这个过�E�中也可以加入优化器来优化代码�?
把目标代码与标准库函数用链接器捆�l�在一��P��用于执行�?/li>

执行�Q?/p>

�E�序载入内存�?
�E�序执行�?
�E�序�l�止�?/li>

攀�?/a> 2006-12-31 16:00 发表评论

伊人色综合久久天天,免费成人黄色av,久久国产婷婷国产香蕉

(�?C++�E�序调用C函数

(�? �ȝ��C++中的所有强制�{换函�?const_cast�Q�reinterpret_cast�Q�static_cast�Q�dynamic_cast)

可以�Ҏ��字符串创建类�?-解决�Ҏ�� 熟练c/c++(�?

C语言怎么解析声明 熟练c/c++(�?

�l�构体对齐那点事 熟练c/c++(�?

public�l�承后，父类与子�c�访问隐�?熟练c/c++(�?

C++怎么实现AOP

�q�回内部静态成�? 熟练C/C++�Q�一�Q?

心情不错

C的实现都是有两个不同的环境：���译与执�?br>

C语言怎么解析声明熟练c/c++(�?

�l�构体对齐那点事熟练c/c++(�?

C的实现都是有两个不同的环境：��译与执�?br>