DirectX3D 学习

学习DirectX3D

重载与覆盖
成员函数被重载的特征:
(1)相同的范围(在同一个类中);
(2)函数名字相同;
(3)参数不同;
(4)virtual关键字可有可无。
覆盖是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类);
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有virtual关键字。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,
规则如下:
(1)如果派生类的函数与基类的函数同名,但是参数不同。
     此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。
     此时,基类的函数被隐藏(注意别与覆盖混淆)。

如下示例程序中:
(1)函数Derived::f(float)覆盖了Base::f(float)。
(2)函数Derived::g(int)隐藏了Base::g(float),而不是重载。
(3)函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。

#include<iostream.h>

class Base{
public:
virtual void f(floatx){cout<<"Base::f(float)"<<x<<endl;}
        void g(floatx){cout<<"Base::g(float)"<<x<<endl;
        void h(floatx){cout<<"Base::h(float)"<<x<<endl;}
};

class Derived:publicBase{
public:
virtual void f(floatx){cout<<"Derived::f(float)"<<x<<endl;}
        void g(intx){cout<<"Derived::g(int)"<<x<<endl;}
        void h(floatx){cout<<"Derived::h(float)"<<x<<endl;}
};
void main(void){
  Derived d;
  Base *pb=&d;
  Derived *pd=&d;
  
  //Good:behavior depends solely on type of the object
  pb->f(3.14f);     //Derived::f(float)3.14
  pd->f(3.14f);     //Derived::f(float)3.14

  //Bad:behavior depends on type of the pointer
  pb->g(3.14f);     //Base::g(float)3.14
  pd->g(3.14f);     //Derived::g(int)3(surprise!)

  //Bad:behavior depends on type of the pointer
  pb->h(3.14f);     //Base::h(float)3.14(surprise!)
  pd->h(3.14f);     //Derived::h(float)3.14

posted @ 2008-09-16 15:28 xpcer 阅读(908) | 评论 (0)编辑 收藏
   
struct test
{
   
int number;
   
double score;
   test
* next;
}

void reverse(test*& head)
{
   test
* pe = head;
   test
* ps = head->next;
   
while(ps != NULL)
   
{
      pe
->next = ps->next;  //save the next point
      ps->next = head;  //reverse
      head = ps;
      ps 
= pe->next;
    }

}
  
posted @ 2008-09-16 13:24 xpcer 阅读(231) | 评论 (0)编辑 收藏

1.            堆区( heap ):由程序员申请分配和释放,属动态内存分配方式,若程序员不释放,程序结束时可能会由 OS 回收。不过这个内存分配很容易引起问题,如果申请的内存不释放就会造成内存泄漏;如果释放的不是所要释放的内存,则轻者引起程序运行结果出错,重者系统崩溃。

2.            栈区( stack ):编译器自动分配释放,存放函数的形参值、局部变量的值,也是属于动态内存分配方式,它由系统分配,所以执行效率也高,不过自由度小,声明时就得决定其具体大小。

3.            全局区(静态区)( static ):全局变量和静态变量的存储是放在一块的,而且初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放,所以也不会造成内存问题。

4.文字常量区和程序代码区,两者都是由系统分配和释放,且文字常量区和前面三区合成为程序数据区,与程序代码区相对应。  

posted @ 2008-09-14 19:08 xpcer 阅读(282) | 评论 (0)编辑 收藏
int a[100];
for(i = 0, c = 0;i<100;i++)
{
    
if(c == 0)
    
{
        t 
= a[i];
        c 
= 1;
        
continue;
    }

    (a[i] 
== t)?c++:c--;
}

return t;

转载
posted @ 2008-09-13 16:41 xpcer 阅读(565) | 评论 (0)编辑 收藏
void palie1(char src[],char buffer[],bool used[],int len,int level)
{
    
if (level==len)
    
{
        cout
<<buffer;
        
return ;
    }


    
for (int i=0;i<len;i++)
    
{
        
if (used[i])
        
{
            
continue;
        }


        buffer[i]
=src[i];
        used[i]
=true;
        palie1(src,buffer,used,len,level
+1);
        used[i]
=false;

    }

}

void pailie(char str[])
{
    
int len=strlen(str);
    
bool used[10];
    
for (int i=0;i<10;i++)
    
{
        used[i]
=false;
    }

    
char out[10];
    palie1(str,
out,used,len,0);
    
}


posted @ 2008-09-13 16:26 xpcer 阅读(211) | 评论 (0)编辑 收藏

 

bool revers(char str[])
{
 
char *buffer;
 
int tokenreadpos,wordreadpos,wordend,writepos=0;

 tokenreadpos
=strlen(str)-1;

 buffer
=(char*)malloc(tokenreadpos+2);
 
if (!buffer)
 
{
  
return false;
 }


 
while (tokenreadpos>=0)
 
{
  
if (str[tokenreadpos]==' ')
  
{
   buffer[writepos
++]=str[tokenreadpos--];
  }

  
else
  
{
   wordend
=tokenreadpos;

   
while (tokenreadpos>=0 && str[tokenreadpos]!=' ')
   
{
    tokenreadpos
--;
   }



   wordreadpos
=tokenreadpos+1;
   
while (wordreadpos<=wordend)
   
{
    buffer[writepos
++]=str[wordreadpos++];
   }

  }

 }



 buffer[writepos]
='\0';
 strcpy(str,buffer);
 free(buffer);
 
return true;
}


 

//以上的程序需要分配内存。。

 

 

///*************************************************************************************

void fun(char str[],int s,int e)
{
 
char temp;
 
while (e>s)
 
{
  temp
=str[s];
  str[s]
=str[e];
  str[e]
=temp;
  s
++;
  e
--;
 }

}


void revers2(char str[])
{
 
int start=0,end=0,len;
 len
=strlen(str);

 fun(str,start,len
-1);

 
//test 
 cout<<"第一次颠倒"<<str<<endl; //

 
while (end<len)
 
{
  
if (str[end]!=' ')
  
{
   start
=end;

   
while(end<len &&str[end]!=' ')
   
{
    end
++;
   }

   end
--;

   fun(str,start,end);
   
  }


  end
++;
 }

 cout
<<"第2次颠倒"<<str<<endl; //

}


 

//以上不需要分配多余的内存
posted @ 2008-09-13 15:59 xpcer 阅读(329) | 评论 (0)编辑 收藏
仅列出标题
共2页: 1 2 

导航

<2025年7月>
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789

统计

常用链接

留言簿(1)

随笔分类

随笔档案

Graphics

搜索

最新评论

阅读排行榜

评论排行榜