life02

String 類的原型如下

class String
{
   public:
          String(const char *str=NULL); //構造函數
          String(const String &other); //拷貝構造函數
          ~String(void); //析構函數
          String& operator=(const String &other); //等號操作符重載

          ShowString();

   private:
          char *m_data; //指針
};

String::~String()
{
    delete [] m_data; //析構函數，釋放地址空間
}
String::String(const char *str)
{
    if (str==NULL)//當初始化串不存在的時候，為m_data申請一個空間存放'\0'；
     {
        m_data=new char[1];
        *m_data='\0';
     }
    else//當初始化串存在的時候，為m_data申請同樣大小的空間存放該串；
     {
        int length=strlen(str);
        m_data=new char[length+1];
        strcpy(m_data,str);
     }
}

String::String(const String &other)//拷貝構造函數，功能與構造函數類似。
{
    int length=strlen(other.m_data);
    m_data=new [length+1];
    strcpy(m_data,other.m_data);
}
String& String::operator =(const String &other)
{
    if (this==&other)//當地址相同時，直接返回；
        return *this; 
 
    delete [] m_data;//當地址不相同時，刪除原來申請的空間，重新開始構造；

    int length=sizeof(other.m_data);
    m_data=new [length+1];
    strcpy(m_data,other.m_data);

    return *this; 
}

 

String::ShowString()//由于m_data是私有成員，對象只能通過public成員函數來訪問；

{

      cout<<this->m_data<<endl;

}

 

 

 

main()
{
String AD;
char * p="ABCDE";
String B(p);
AD.ShowString();
AD=B;
AD.ShowString();

}

http://www.cnblogs.com/cutepig/archive/2009/02/10/1387761.html
dynamic_cast:   通常在基類和派生類之間轉換時使用,run-time   cast  
   
  const_cast:   主要針對const和volatile的轉換.  
   
  static_cast:   一般的轉換，no   run-time   check.通常，如果你不知道該用哪個，就用這個。  
   
  reinterpret_cast:   用于進行沒有任何關聯之間的轉換，比如一個字符指針轉換為一個整形數。


http://blog.csdn.net/goodluckyxl/archive/2005/01/19/259851.aspx

強制轉化四種類型可能很多人都常常忽略就象我一樣，但是有時還是比較有用的。不了解的建議看看，一些機制我也不是十分了解，只是將一些用法寫出來讓大家看看。
                                                            2004-11-27 9:00

強制轉化無論從語法還是語意上看，都是c++中最難看的特征之一。但是基于c風格的轉化的語義的不明確性及其一些潛在問題。強制類型轉化最終還是被c++接受了。
1.static_cast運算符號
static_cast<T>(e),stroustrup讓我們可以把它看成隱含轉換的顯示的逆運算。這個是有一定道理的，基于隱式轉化的對象類型我們可以使用static_cast轉化運算符號。它是靜態的檢測，無法運行時檢測類型，在繼承中尤為突出。
使用范圍
<1>用于所有系統類型之間轉化，不能用于系統類型指針類型轉化
  double t_d = 0;
int t_i= static_cast<int>(t_d); //是合法的轉化
而企圖將double*->int*是不允許的
<2>用于繼承類之間的轉化（含指針），不能用于其他沒有隱式轉化的對象類型之間的轉化
繼承舉例:
class x
{
};
class y: public x
{
};
使用:x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //x* y*轉化也可以進行因為x,y繼承關
//系，類型可以自動隱式轉化使用
   隱式轉化舉例:
class x
{
};
class y
{

public:
    y( x i_x ) {}
};
    x t_o_x;
     y t_o_y = static_cast<y>(t_o_x); //大家看到y構造函數可以對于x類型隱式轉化
//所以可以將x->y，如果企圖將y->x會報錯
2.reinterpret_cast 運算
主要用于對于類型指針類型的強制轉化，some_type* -> special_type*這樣轉化，類型信息可以是不完全的。它允許將任意指針轉化到其他類型指針，也允許任意整數類型到任意指針類型轉化(BT)。這樣導致的結果是極其不安全的，不能安全的應用于其他目的，除非轉化到原來類型。
<1> 使用所有整形可以轉化為任意類型的指針(指針是4字節的long的東東，那么機器就認為同類型就是可以轉化)
int c;
x* p = reinterpret_cast<x*>(c); //x是自定義的任意類型，當然包括系統類型
<2> 可以對于任意類型指針之間轉化
y* c;
x* p = reinterpret_cast<x*>(c);//x,y代表所有自定義或系統類型
大家可以看到reinterpret_cast的轉化是極度的不負責任的，他只管轉化不檢測是否可以轉化。
<3> const_cast運算符號
這個很簡單從名字大家可以看出來，僅僅為了去掉或著加上const修飾符號。但是對于本身定義時為const的類型，即使你去掉const性，在你操作這片內容時候也要小心，只能r不能w操作，否則還是會出錯。
const char* p = "123";
char* c = const_cast<char*>(p);
c[0] = 1;  //表面上通過編譯去掉了const性，但是操作其地址時系統依然不允許這
//么做。這是一個漏洞吧
<4> dynamic_cast運算符號
Scott Mayers將其描述為用來執行繼承體系中：安全的向下轉型或者跨系轉型動作。也就是說你可以，用dynamic_cast將 指向base class的指針或引用轉型為 指向子類的對象的指針或引用。
class B {};  //polymorphic類型含virtual才能dynamic_cast
class D: public B {}
void f( B* pb )
{
    D* pd1 = dynamic_cast<D*>(pb);//如果pb為d類型正確返回，如果不是返回0
    D* pd2 = static_cast<D*>(pb); //不管怎么樣都返回指針有可能指向不合適的對
//象，因為static僅僅靜態檢測，不能得到運
//行時對象的信息是否真正為D類型
}

反正大家在使用知道怎么用就ok了，c++強制轉化在模板中還是非常有用的，其他時候本人也喜歡用c的轉化方便。^_^     

http://www.vckbase.com/document/viewdoc/?id=1651

static_cast<>揭密


作者：Sam NG

譯者：小刀人

原文鏈接：What static_cast<> is actually doing

本文討論static_cast<> 和 reinterpret_cast<>。

介紹
大多程序員在學C++前都學過C，并且習慣于C風格（類型）轉換。當寫C++（程序）時，有時候我們在使用static_cast<>和 reinterpret_cast<>時可能會有點模糊。在本文中，我將說明static_cast<>實際上做了什么，并且指出一些將會導致錯誤的情況。

泛型（Generic Types）

        float f = 12.3;

        float* pf = &f;

// static cast<>

        // 成功編譯, n = 12

        int n = static_cast<int>(f);

        // 錯誤,指向的類型是無關的（譯注：即指針變量pf是float類型，現在要被轉換為int類型）
        //int* pn = static_cast<int*>(pf);

        //成功編譯

        void* pv = static_cast<void*>(pf);

        //成功編譯, 但是 *pn2是無意義的內存（rubbish）

        int* pn2 = static_cast<int*>(pv);


// reinterpret_cast<>

        //錯誤,編譯器知道你應該調用static_cast<>

        //int i = reinterpret_cast<int>(f);

        //成功編譯, 但是 *pn 實際上是無意義的內存,和 *pn2一樣

        int* pi = reinterpret_cast<int*>(pf);

簡而言之，static_cast<> 將嘗試轉換，舉例來說，如float-到-integer，而reinterpret_cast<>簡單改變編譯器的意圖重新考慮那個對象作為另一類型。

指針類型（Pointer Types）

指針轉換有點復雜，我們將在本文的剩余部分使用下面的類：

class CBaseX

      {

      public:

      int x;

      CBaseX() { x = 10; }

      void foo() { printf("CBaseX::foo() x=%d\n", x); }

      };

class CBaseY

        {

        public:

        int y;

        int* py;

        CBaseY() { y = 20; py = &y; }

        void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); 
        }

        };


class CDerived : public CBaseX, public CBaseY

        {

        public:

        int z;

        };

情況1：兩個無關的類之間的轉換

      // Convert between CBaseX* and CBaseY*

      // CBaseX* 和 CBaseY*之間的轉換

      CBaseX* pX = new CBaseX();

      // Error, types pointed to are unrelated

      // 錯誤， 類型指向是無關的

      // CBaseY* pY1 = static_cast<CBaseY*>(pX);

      // Compile OK, but pY2 is not CBaseX

      // 成功編譯, 但是 pY2 不是CBaseX

      CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);

      // System crash!!

      // 系統崩潰!!

      // pY2->bar();

正如我們在泛型例子中所認識到的，如果你嘗試轉換一個對象到另一個無關的類static_cast<>將失敗，而reinterpret_cast<>就總是成功“欺騙”編譯器：那個對象就是那個無關類。

情況2：轉換到相關的類

      1. CDerived* pD = new CDerived();

      2. printf("CDerived* pD = %x\n", (int)pD);

      3. 

      4. // static_cast<> CDerived* -> CBaseY* -> CDerived*

      //成功編譯，隱式static_cast<>轉換

      5. CBaseY* pY1 = pD;

      6. printf("CBaseY* pY1 = %x\n", (int)pY1);

      // 成功編譯, 現在 pD1 = pD

      7. CDerived* pD1 = static_cast<CDerived*>(pY1);

      8. printf("CDerived* pD1 = %x\n", (int)pD1);

      9. 

      10. // reinterpret_cast

      // 成功編譯, 但是 pY2 不是 CBaseY*

      11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);

      12. printf("CBaseY* pY2 = %x\n", (int)pY2);

      13. 

      14. // 無關的 static_cast<>

      15. CBaseY* pY3 = new CBaseY();

      16. printf("CBaseY* pY3 = %x\n", (int)pY3);

      // 成功編譯,盡管 pY3 只是一個 "新 CBaseY()"

      17. CDerived* pD3 = static_cast<CDerived*>(pY3);

      18. printf("CDerived* pD3 = %x\n", (int)pD3);

      ---------------------- 輸出 ---------------------------

      CDerived* pD = 392fb8

      CBaseY* pY1 = 392fbc

      CDerived* pD1 = 392fb8

      CBaseY* pY2 = 392fb8

      CBaseY* pY3 = 390ff0

      CDerived* pD3 = 390fec

      

注意：在將CDerived*用隱式 static_cast<>轉換到CBaseY*（第5行）時，結果是（指向）CDerived*（的指針向后） 偏移了4（個字節）（譯注：4為int類型在內存中所占字節數）。為了知道static_cast<> 實際如何，我們不得不要來看一下CDerived的內存布局。

CDerived的內存布局（Memory Layout）



如圖所示，CDerived的內存布局包括兩個對象，CBaseX 和 CBaseY，編譯器也知道這一點。因此，當你將CDerived* 轉換到 CBaseY*時，它給指針添加4個字節，同時當你將CBaseY*轉換到CDerived*時，它給指針減去4。然而，甚至它即便不是一個CDerived你也可以這樣做。
當然，這個問題只在如果你做了多繼承時發生。在你將CDerived轉換 到 CBaseX時static_cast<> 和 reinterpret_cast<>是沒有區別的。

情況3：void*之間的向前和向后轉換

因為任何指針可以被轉換到void*，而void*可以被向后轉換到任何指針（對于static_cast<> 和 reinterpret_cast<>轉換都可以這樣做），如果沒有小心處理的話錯誤可能發生。

    CDerived* pD = new CDerived();

        printf("CDerived* pD = %x\n", (int)pD);

    CBaseY* pY = pD; // 成功編譯, pY = pD + 4

        printf("CBaseY* pY = %x\n", (int)pY);


      void* pV1 = pY; //成功編譯, pV1 = pY

        printf("void* pV1 = %x\n", (int)pV1);


         // pD2 = pY, 但是我們預期 pD2 = pY - 4

        CDerived* pD2 = static_cast<CDerived*>(pV1);

        printf("CDerived* pD2 = %x\n", (int)pD2);

        // 系統崩潰

        // pD2->bar();

        ---------------------- 輸出 ---------------------------

        CDerived* pD = 392fb8

        CBaseY* pY = 392fbc

        void* pV1 = 392fbc

        CDerived* pD2 = 392fbc

     

一旦我們已經轉換指針為void*，我們就不能輕易將其轉換回原類。在上面的例子中，從一個void* 返回CDerived*的唯一方法是將其轉換為CBaseY*然后再轉換為CDerived*。
但是如果我們不能確定它是CBaseY* 還是 CDerived*，這時我們不得不用dynamic_cast<> 或typeid[2]。

注釋：
1. dynamic_cast<>，從另一方面來說，可以防止一個泛型CBaseY* 被轉換到CDerived*。
2. dynamic_cast<>需要類成為多態，即包括“虛”函數，并因此而不能成為void*。
參考：
1. [MSDN] C++ Language Reference -- Casting
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs
3. Juan Soulie, C++ Language Tutorial: Type Casting
推薦鏈接：如何在運行時確定對象類型（RTTI）

2009.9.12日下午 迅雷2筆試題
一
有一副牌編號0~51，請把這副牌盡可能隨機的發到4個人手里
注1：已經有rand()函數可以調用，但是rand()函數開銷較大，請盡量少調用

a,b,c,d分別是13個元素的1維數組
函數原型 void deal( int[] a, int[] b, int[] c, int[] d );

二
實現字符串反轉的c庫函數 char* strrev(char* string)
注1：不可利用其他庫函數，算法盡量高效、占用空間少。

三
有10億個數，這些數的值都在0~1000萬之內。實現接口 get_bigger_count( unsigned value )
輸入一個值value，返回這10億個數中比value值大的數的數目。
class order_calculate
{
public:
order_calculate();
~order_calculate();
unsinged get_bigger_count( unsigned value )
}
注1：get_bigger_count接口會被頻繁的調用，實現要高效
注2：可以自己往內部任意添加變量和接口
注3：有個現成的接口 unsigned get_value_by_index( int idx ) 可以調用，該接口返回指定索引的value值
     比如 get_value_by_index( 100 )， 返回10億個數中第100個數的值。該接口開銷較大，盡量少調用。

http://topic.csdn.net/u/20090912/20/8c60e06e-321c-49a6-b2cc-59248ba9cf36.html?28642 

     摘要:   閱讀全文

     摘要:   閱讀全文

如何成為一個游戲人工智能開發者
原文地址：http://www.ai-blog.net/archives/000150.html
作者：Paul Tozour June 11, 2008
譯者：賴勇浩(http://blog.csdn.net/lanphaday) July 10, 2008                        
業界一直需要杰出的 AI 開發者，我想我可以在這里分享一些關于學習業界所需技術的看法，以幫助大家更好地進入游戲 AI 開發者的角色。
其實幾個月前我就已經寫了這一篇文章，但直到 Dave Mark 在 aigamedev.com 發表了這篇文章(http://aigamedev.com/discussion/industry-knowledge)，我才決心發表出來。
首要的是，著眼于開發技能，在嘗試專精之前先博覽游戲開發領域所有的技能。
先博而后專
游戲工作室通常并不會把初級程序員任命為AI工程師。我們需要對游戲源碼的方方面面都非常了解的工程師，這意味著他有多年游戲開發經驗，而且能夠隨時插入到任一特定領域 “救火”。新進員工常常被要求幫助一個接近交貨日期的項目，通常是填補空缺，做一些簡單可控的或者團隊中沒有人能抽出時間（興趣）來做的事。
你可以對你的面試官說明你對游戲 AI 工程非常有興趣，而且打算以它為長期目標；但你要做好進入業界的前幾年都與特定領域無緣的打算。
記住成為一個通才很重要，一個 AI 開發者需要堅實的游戲開發基礎技能。對現代游戲引擎的各個組件都相當了解，因為從一個實際項目中獲得的經驗無可替代。
所以最為首要的就是學習你成為一個杰出工程師所需要的技能，對于大多數開發者來說，它包括：
u       精通 C++ 與 STL。
u       能夠編寫健壯的、可讀的代碼。
u       精通算法與數據結構。
u       精通面向對象理論。
u       務實的態度，愿意采用“自底向上”的方式解決問題。
u       了解代碼測試和防御式編程（例如：利用C++語言特征去最小化出現缺陷的可能性和強制編譯器與連接器在出現問題的時候“大叫一聲“）。
u       愿意使用剖分器驅動的性能優化：在嘗試動手優化之前先找出真正需要優化的地方，在使用奇技淫巧和手寫匯編之前先使用算法優化。
u       精通如何高效使用內存資源
u       廣泛理解現代游戲引擎架構
u       有堅實的3D 數學基礎（對游戲中需要用到的部分而言）
u       良好的團隊交流和合作精神
EDIT：這里強烈推薦一系列我書架上的通用工程技術書籍，包括《Effective C++》、《More Effective C++》、《C++ Coding Standards》、《Code Complete》、《The C++ Programming Language》、《3D Math Primer for Graphics and Game Development》等。（譯注：這些書都有中文版。）
編寫一個示例程序
想給公司留下一個深刻的印象？一個簡單有效的方法是用 C++ 編寫一個示例程序（是的，你可能使用 Java 或者 C#，但業界趨向于在游戲里排它地使用 C++，Java 和 C# 只在做工具的時候用到）。你的程序不必在圖形上看起來很炫，但需要能夠表現出你是如何做的和如何想的。不要使用你在學校的團隊項目，你單獨完成他，才能獲得所有好評。
尤為重要的是你最好能夠提供源代碼，這樣你可以給面試官一個 demo 和創建它的示例代碼。努力讓你的代碼穩定、可讀，盡可能地沒有 bug，并且做好回答關于“當你編寫代碼的時候為什么作出這樣的選擇”的問題的準備。
堅持
當你打好了作為開發人員的基礎，完成了一個很好的示例程序后，盡可能地與更多地公司接洽。然后努力地做獨立編程測試，無論你在業界已經多久，這都能夠增進你的技能。
當遇到很難的面試題時，盡量打起精神來嘗試解決問題，但也不要不敢向面試官尋求幫助，面試也是在測試你如何處理壓力，以及解決問題的決心，以及當你的思維原地打轉或者毫無頭緒時是否善于溝通。
務實
最后，如果你與面試官談起 AI，切記要務實。你要意識到學術環境中的“人工智能”與我們口中的“游戲 AI”的不同，也要意識到業界宣揚的游戲 AI 并沒有達到他們所承諾的那種高度。
當你和面試官談起神經網絡或者其它機器學習技術的時候，他們可能會有點排斥感，因此你應當能夠準確地描述它們與游戲 AI 的關系（苛刻點說，可以認為仍然有一些開發者認為任何 AI 都是多余的）。
面試官非常善于認清一個人是不是鼻眼朝天的自大者，因此你必須盡力地展現你務實的一面。
弄清關于游戲 AI 的挑戰很重要，也要清楚地認識到它適用于哪些方面。可以參考一下我不久前的一篇文章（http://www.ai-blog.net/archives/000145.html），里面列出了一系列 AI 開發者常常會遇到的問題。
從事 AI 開發是非常值得嘗試的，如果你能夠找到合適的公司和合適的項目的話。
祝您好運！

本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/lanphaday/archive/2008/07/10/2635783.aspx

     摘要:   閱讀全文