• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            f(sixleaves) = sixleaves

            重劍無鋒 大巧不工

              C++博客 :: 首頁 :: 新隨筆 :: 聯(lián)系 :: 聚合  :: 管理 ::
              95 隨筆 :: 0 文章 :: 7 評論 :: 0 Trackbacks

            #

            總結(jié)下cocos2dx的這些動作,知識大概的總結(jié),不是包含所有。文中的名詞是自己取得。
            首先我們要把握主線,我們在cocos2dx用到的動作都是派生自Action類,而Action又派生自Ref類。而我們主要用到的時屬于Action派生的FiniteTimeAction(有限時間的動作類)類所派生的類。
            FiniteTimeAction中得有限時間類又分為兩個部分,一個部分是瞬時動作類(ActionInstant),也就是執(zhí)行時你是看不到過程,只能看到結(jié)果。一部分是ActionInterval(持續(xù)動作類),這類動作都是有持續(xù)時間的。
            1.框架:
            Action類派生出:FiniteTimeAction
            #FiniteTimeAction類派生出:ActionInstant類和ActionInterval類
            ##ActionInstant類派生出:CallFunc類、FlipX、Hide、Place(這里只是列出我常用的)
            ##ActionInterval類派生出:又分為兩大類,一大類是純持續(xù)動作類、一大類是動作包裝類(這是我自己細分的)
            其中純持續(xù)動作類包括:BezierBy(To)(貝茲爾曲線動作)、Blink(閃爍動作)、FadeIn(Out)、JumpBy(To)(跳轉(zhuǎn)動作,指定起跳位置、高度、次數(shù))、RotateBy(To)、ScaleBy(To)(拉伸動作)。
            其中一般By是相對的意思當前位置或者倍數(shù),To是指定絕對。第一個參數(shù)都是指定持續(xù)時間。
            其中動作包裝類包括::Repeat、RepeatForever、Sequence、Spawn,動作包裝類對所包裝的動作有一定副作用,其副作用一般可顧名思義。
            如上,Repeat包裝后的動作就是重復(fù)指定次數(shù)被包裝的動作、RepeatForever則是持續(xù)不斷、Sequence可以包裝多個動作、其副作用是讓多個動作順序執(zhí)行
            Spawn包裝后的動作的副作用是,所有動作一起執(zhí)行。

            2.動作的創(chuàng)建:
            一般動作的創(chuàng)建是調(diào)用相應(yīng)動作的類的create工廠方法。

            3.動作的執(zhí)行:
            一般動作的是發(fā)送runAction消息給指定的Sprite對象,傳入?yún)?shù)就是動作對象。

            4.幾個重要動作Sequence、Spawn、CallFunc
            Sequence動作的使用就是如代碼:
            auto actions = Sequence::create(action1,action2,...,actionN, NULL);
            sprite->runAction(actions);
            Spawn的使用也一樣,知識把關(guān)鍵字替換掉
            CallFunc動作是我們就稱為回調(diào)動作把(或者說是把函數(shù)轉(zhuǎn)化為動作),傳入的第二個函數(shù)指針需要通過callFunc_selector格式化該函數(shù)指針。
            auto actionCF= CallFunc::create(this, callFunc_selector(HelloWord::sayLove));

            posted @ 2014-09-28 16:13 swp 閱讀(1258) | 評論 (0)編輯 收藏

            在寫程序中,我們經(jīng)常要判斷,或者寫個循環(huán),具體讓其循環(huán)幾次,這個怎么計算。
            我分別舉幾個例子。
            eg1:for (i = 0; i < n; i++);
            這個是大家再熟悉不過的了,為什么它是n次循環(huán),如果我能用數(shù)學(xué)的角度看是這樣的,首先i的取值范圍中,每個整數(shù)對應(yīng)一個
            循環(huán),所以所謂的循環(huán)次數(shù),也就是這個范圍內(nèi)的整數(shù)的個數(shù)。而上述的循環(huán)范圍是[0, n).它的整數(shù)個數(shù)就是n - 0 = n,只有
            對于半閉合半開放的區(qū)間能這樣計算,這也是為什么從0開始計數(shù)的好處之一。一目了然。
            eg2:
            while(L--) {
            }
            這個循環(huán)循環(huán)幾次呢,首先我們確定L的有效范圍,由于是后置減減,所以有效范圍是[L, 0).所以循環(huán)也是L次
            如果是
            while(--L){},那范圍就是[L-1, 0),所以其循環(huán)次數(shù)是L - 1
            posted @ 2014-09-23 21:02 swp 閱讀(1117) | 評論 (0)編輯 收藏

            題目描述

            為了縮短領(lǐng)救濟品的隊伍,NNGLRP決定了以下策略:每天所有來申請救濟品的人會被放在一個大圓圈,面朝里面。選定一個人為編號 1 號,其他的就從那個人開始逆時針開始編號直到 N。一個官員一開始逆時針數(shù),數(shù) k 個申請者,然后另一個官員第 N 個始順時針方向數(shù) m 個申請者,這兩個人就被送去再教育。如果兩個官員數(shù)的是同一個人,那個人則被送去從政,然后2個官員再在剩下的人里面繼續(xù)選直到?jīng)]人剩下來,注意兩個被選 中的人是同時走掉的,所以就有可能兩個官員選中一個人。

            [編輯]Input

            輸入含有多組測試資料,每組測試資料一列含有三個數(shù) N,k 和 m(k, m > 0,0<N<20)。 當輸入為 0 0 0 代表輸入結(jié)束。

            [編輯]Output

            對每組測試資料輸出一列。輸出被選中的申請者的編號順序(一對一對的)。每個數(shù)的寬度為 3 。每一對前面的那個編號為逆時針數(shù)的官員選出的,后面的那個編號為順時針數(shù)的官員選出的(但是如果這2個官員選出同一個人,那就只會有一個編號)。每一對 之間以逗號分開。格式請參考Sample Output。

            [編輯]Sample Input

            10 4 3 
            13 17 42
            7 8 47
            0 0 0

            [編輯]Sample Output

             4 8, 9 5, 3 1, 2 6, 10, 7 
            4 11, 10 1, 8 6, 13 7, 3, 5 12, 9 2
            1 3, 5 7, 2 4, 6
            這道題目有點繞,也講得不嚴密。這里主要說下幾個容易錯的地方。
            首先是你每次在寫程序之前,都要十分清除規(guī)則,題目中的人是圍著一圈,而且第一個的左邊是第N個人,也就是它是逆時針標號的。這個十分關(guān)鍵。
            其次是go函數(shù)的實現(xiàn),go函數(shù)是數(shù)過L個人,返回最后一個的位置。我并不贊同,某些版本數(shù)組是從1開始計數(shù),因為這樣對于表達式的表達十分不方便。你可以
            自己嘗試用1來做,會很不方便。就是因為go函數(shù)是這樣一個函數(shù),所以當我們在下一次迭代的時候的開始位置,一定是為那個人出去的位置,也就是a[i]=0的位置。
            所以我們第一次迭代的位置,原本A是應(yīng)該在位置0,B在位置n-1。這時候只能是A在n-1和B在0.(你可以用數(shù)學(xué)歸納法理解)。
             1 #include <stdio.h>
             2 
             3 #define MAXN 25
             4 int n,k,m;
             5 int a[MAXN];
             6 int go(int p, int d, int k);//數(shù)過k個人,開始位置p必須是數(shù)1時候的前一個位置。 
             7 int main() {
             8     while (scanf("%d%d%d", &n, &k, &m) == 3 && n) {
             9         for (int i = 0; i < n; i++) {
            10             a[i] = i + 1;
            11         }
            12         int left = n;
            13         int pA = n-1, pB = 0;
            14         int pANext,pBNext;
            15         while (left) {
            16             pA = go(pA, 1, k);//1表示逆時針,因為它是逆時針標號
            17             pB = go(pB, -1, m);//-1表示順時針
            18             printf("%3d", pA + 1); left--;
            19             if (pA != pB) { printf("%3d", pB + 1); left--;}
            20             a[pA] = a[pB] = 0;
            21             if (left) printf(",");
            22         }
            23         printf("\n");
            24     }    
            25     return 0;
            26 }
            27 int go(int p, int d, int L) {
            28     while (L--) {
            29         do { p = (p+n+d)%n;} while(a[p] == 0);
            30     }
            31     return p;
            32 }
            解析:至于下一個位置為什么是p = (p+n+d)%n.其實很簡單。因為我們是一步步走的,所以只有兩種邊界情況。假設(shè)當前位置是p(0=<p<n),
            第一種邊界:p + 1 > n - 1,即 p + 1此時應(yīng)該是到達0位置,但此時p + 1 = n,如果我們?nèi)∮鄶?shù),則 (p+1)%T = 0,T = n(T表示這個圓圈的周期大小)。
            剛好能符合,又因為T = n,所以(P+T+1)%T還是不變的。
            第二種邊界: p - 1 < 0, 即 p - 1此時的值是-1,對于這種情況可以反過來看,它是向后退后1個單位,可以看成向前走T - 1個單位即p -1 等效于 p + T - 1
            ,我們要等到此時的位置,再去余,(P+T-1)%T。
            對于情況一、二。可以歸納為(P+T+d)%T,當為順時針是d取1,否則-1.
            posted @ 2014-09-23 20:46 swp 閱讀(1835) | 評論 (0)編輯 收藏

            1.創(chuàng)建對象:

                 在java中創(chuàng)建對象只能用new才行,返回的是引用類型,所以對象名其實是引用。而C++中的對象創(chuàng)建不一樣,C++可以用指針存對象,相當于引用。也可以直接用類標識符來創(chuàng)建對象。如Person是類,Person a,b;在C++中就創(chuàng)建了兩個對象,在java中是Person對象的引用。

            2.C++中了this指針:

                 C++中的this指針和java中的一樣。在C++中,this指針指向當前對象,this指針隱含在每個成員函數(shù)之中,其類型是class className *.

                 內(nèi)部機制:

                 在C++中訪問數(shù)據(jù)成員都是隱含的使用this指針操作的。需要注意的是。

                 1.this指針是const類型,不可改變。

                 2.this指針針對對象,所以靜態(tài)成員是沒有this指針的。

            3.構(gòu)造函數(shù)和析構(gòu)函數(shù)

                 構(gòu)造函數(shù)就不說了,只說下默認構(gòu)造函數(shù)就死className() {},默認會生成。但是如果你自己定義了構(gòu)造函數(shù),而且不是定義成默認構(gòu)造函數(shù),就要在定義一下默認構(gòu)造函數(shù),不然創(chuàng)建對象時候必須指定參數(shù),不能用無參數(shù)的。

                 析構(gòu)函數(shù),就是用來在對象要銷毀時候,回收一些對象自己向系統(tǒng)申請的內(nèi)存。析構(gòu)函數(shù)調(diào)用完后,系統(tǒng)才清除對象本身占據(jù)的內(nèi)存。

                  Tips:

                   1.析構(gòu)函數(shù)不能重載,只有一種形式~className() {},這是和構(gòu)造函數(shù)的區(qū)別

                   2.三種情況下調(diào)用析構(gòu)函數(shù),對象離開局部作用域后,撤銷對象觸發(fā),程序終止,觸發(fā);delete運算符回收new創(chuàng)建的對象觸發(fā);臨時匿名函數(shù)使用完畢;

            4.拷貝構(gòu)造函數(shù)和單參構(gòu)造函數(shù)

                    (1)拷貝構(gòu)造函數(shù),其實就是構(gòu)造函數(shù)中的單參數(shù)形式的構(gòu)造函數(shù),只是其參數(shù)比較特別,是對自身同類對象的引用。拷貝構(gòu)造函數(shù)在一下幾個的方會用到。

                     Date a;Date b(a);//調(diào)用的就是拷貝構(gòu)造函數(shù)

                     Date b = a;//調(diào)用的也是拷貝構(gòu)造函數(shù)

                     function(Date d){….};function(a);//調(diào)用的也是拷貝構(gòu)造函數(shù)(先創(chuàng)建Date類的匿名對象,然后調(diào)用拷貝構(gòu)造函數(shù))

                     Date c = function(a);//這邊f(xié)unction返回Date對象,也是調(diào)用拷貝構(gòu)造函數(shù)(沒有創(chuàng)建匿名對象)

                     (2)單參構(gòu)造函數(shù)

                      單參數(shù)構(gòu)造函數(shù)。其實拷貝構(gòu)造函數(shù)也是單參構(gòu)造函數(shù)。但是我將他們區(qū)別開來,主要是單參構(gòu)造函數(shù),主要是用在,隱式的類型轉(zhuǎn)換上。

                      如你定義了一個Integer類,直接Integer a = 1;是會出錯的。因為1不能自動或者隱含的轉(zhuǎn)換成Integer對象,所以這時候你就要定義

                      單參數(shù)構(gòu)造函數(shù),用來讓自動轉(zhuǎn)換,在java中稱為包裝。由于是構(gòu)造函數(shù),參數(shù)中的類型就是那個要轉(zhuǎn)換的類型。其它和基本構(gòu)造函數(shù)一樣。

            5.靜態(tài)成員

                    靜態(tài)成員又分為靜態(tài)數(shù)據(jù)成員和靜態(tài)函數(shù)成員。C++中的靜態(tài)函數(shù)成員和java也沒區(qū)別。主要是靜態(tài)數(shù)據(jù)成員。所以我們總結(jié)下靜態(tài)數(shù)據(jù)成員

                  (1)靜態(tài)數(shù)據(jù)成員和類共存亡而不是和對象。

                  (2)靜態(tài)數(shù)據(jù)成員在類加載時候分配空間并進行初始化,而不是在對象加載時候。所以靜態(tài)數(shù)據(jù)成員默認初始化為0。

                         重點是:類中的靜態(tài)數(shù)據(jù)成員知識一份聲明,必須在類外重新定義并初始化靜態(tài)數(shù)據(jù)成員。

                  (3)類外通過類作用域運算符::訪問靜態(tài)數(shù)據(jù)成員。

            6.const用法

                    (1)const成員函數(shù),這時候const加載函數(shù)名后面 {}之前。表示函數(shù)不會改變當前對象的狀態(tài),而且只能調(diào)用const成員函數(shù)。(養(yǎng)成習慣,能加盡量加)

                           Tips:這里const也是函數(shù)簽名的一部分。

                    (2)const對象,表示常量對象。

                    (3)const形參,表示函數(shù)中不會改變該形參。注意:常量對象,只能調(diào)用const成員函數(shù),因為這才能保證狀態(tài)不被改變,同時這樣保證了他就是常量對象。

                            Tips:這里const也是函數(shù)簽名的一部分。

                     (4)const返回值,說明返回值是不可以改變的。

            以上這些都是總結(jié),不是寫給沒基礎(chǔ)的人看的。只是為了方便整理和記憶。

            posted @ 2014-09-04 17:18 swp 閱讀(320) | 評論 (0)編輯 收藏

            這道題目是大數(shù)加法。總結(jié)一些一點經(jīng)驗。

            (1)整值函數(shù)的應(yīng)用。(這個不懂的話,去看我Math欄目下有這個分析)

            (2)sscanf、sprintf的應(yīng)用

            (3)分塊計算的格式問題。

            先直接看代碼:
                
             1 #include <iostream>

             2 #include <cstdio>
             3 #include <vector>
             4 #include <cstring>
             5 using namespace std;
             6 struct BigInteger {
             7     static const int BASE = 100000000;
             8     static const int WIDTH = 8;
             9     vector<int> s;
            10     
            11     BigInteger(long long num = 0) {
            12         *this = num;
            13     }
            14     
            15     BigInteger operator=(long long num) {
            16         s.clear();
            17         do {
            18             s.push_back(num % BASE);
            19             num /= BASE;
            20         }while (num > 0);
            21         return *this;
            22     }
            23     
            24 
            25     BigInteger operator=(const string& str) {
            26         s.clear();
            27         int x;
            28         int len = (str.size() - 1) / WIDTH + 1;//這里有人看不懂,請看我寫的整值函數(shù) 
            29         for (int i = 0; i < len; i++) {
            30             int end = str.size() - i * WIDTH;
            31             int start = max(0, end - WIDTH);//確定分割的區(qū)間為[start, end)是左閉右開,長度就是end - start 
            32             sscanf(str.substr(start, end - start).c_str(), "%d", &x);
            33             s.push_back(x);
            34         }
            35         return *this;
            36     }
            37     
            38     BigInteger operator+(const BigInteger& bi) const{
            39         BigInteger temp;
            40         temp.s.clear();
            41         for (int i = 0,g = 0;;i++) {
            42             
            43             if (g == 0 && i >= s.size() && i >= bi.s.size()) break;
            44             int x = g;
            45             if (i < s.size()) x += s[i];
            46             if (i < bi.s.size()) x += bi.s[i];
            47             temp.s.push_back(x % BASE);
            48             g = x / BASE;
            49         }
            50         return temp;    
            51     }    
            52     
            53     BigInteger operator +=(const BigInteger& b) {
            54         *this = *this + b;return *this;
            55     }
            56 };
            57 
            58 istream& operator >>(istream &in, BigInteger& x) {
            59     string s;
            60     if (!(in >>s)) return in;
            61     x = s;
            62     return in;
            63 }
            64     
            65 ostream& operator <<(ostream &out, BigInteger&bi) {
            66     out << bi.s.back();
            67     for (int i = bi.s.size()-2; i >= 0; i--) {//再從倒數(shù)第二個輸出 
            68         char buf[20];
            69         sprintf(buf, "%08d", bi.s[i]);
            70         //cout << buf;
            71         for (int j =0; j < strlen(buf); j++) out << buf[j];
            72     }
            73     return out;
            74 }
            75 
            76 int main() {
            77     int n;
            78     BigInteger a,b,c;
            79     cin >> n;
            80     int kase = 1;
            81     while (n) {
            82         cin >> a >> b;
            83         c = a + b;
            84         if (n != 1)
            85            cout <<"Case " << kase++ << ":" << "\n" << a << " + " << b << " = " << c << endl << endl;
            86         else
            87            cout <<"Case " << kase++ << ":" << "\n" << a << " + " << b << " = " << c << endl;
            88         n--;
            89     }
            90     return 0;
            91 }
            (1)(2)略。
            (3)分塊處理的坑:

            前面兩個我就不總結(jié)了,這里主要說下,分塊計算的坑。假設(shè)有這個字符串"123400000001",由于我們要將其
            按照沒8位字符分成一塊所以第一塊就是00000001、第二快就是1234,然后按照小端存儲格式、低地址對應(yīng)低位
            但是但他們用sscanf格式化成整數(shù)時候,00000001不可能還是這樣,這樣就是八進制了,而是變成了1,所以我們
            在輸出的時候,除了最高位對應(yīng)的那一塊可能不足8位,剩下的塊肯定都要8位處理,所以上面代碼,才從第二快進行
            輸出,而且格式是%08d.
            posted @ 2014-09-04 14:56 swp 閱讀(1493) | 評論 (0)編輯 收藏

            最近寫程序的時候、碰到一個問題。其實就是將celing函數(shù)用C++默認的除法運算(向下取整)表示出來。所以我打算總結(jié)下整值函數(shù)。

            Firth.首先我們要熟悉頂函數(shù)和底函數(shù),最好的方式就是了解他們的圖形。

            由于數(shù)學(xué)符號在這里不好寫出來,我們用floor來表示底,celing表示頂。

            圖形其實就是以f(x) = x 為分界線,這邊就不畫出來了。向下取整組成的坐標點就是(x, floor(x))

            這些剛好就是在f(x) = x下方的,而向上取整則是在上方的。

            Tips:

            所以從圖像中我們可以發(fā)現(xiàn)一下兩個等式(位移、奇函數(shù))

            1.x – 1 < floor(x) <= x <= celing(x) < x + 1 (可以通過位移圖像來得出該不等式)

            2.floor(-x) = – celing(x) 或者 celing(-x) = – floor(x) (這個其實可以簡單記為奇函數(shù))

             

            Second.兩條法則(你要細分成4條我也不反對)

            1.floor(x) = n 等價于 n <= x < n + 1 等價于 x – 1 < n <= x

            2.celing(x) = n 等價于 n - 1 < x <= n 等價于 x <= n < x + 1

            Tips:

            1.其中n是整數(shù),x是實數(shù)

            2.floor(x + n) = floor(x) + n (因為有上面法則有 floor(x) + n <= x + n < floor(x) + n + 1).

            3.但floor(nx) != n*floor(x)

             

            Third.實數(shù)和整數(shù)之間的關(guān)系,其實都等價于一個頂或底函數(shù)于整數(shù)的關(guān)系。

            1.x < n 等價于 floor(x) < n

            2.n < x 等價于 n < celing(x)

            3.x <= n 等價于 celing(x) <= n

            4.n <= x 等價于 n <= floor(x)

            Tips

            1.celing相當于擴大、floor相當于縮小

            2.取到n,則看能取到最大或者最小,最大取celing、最小floor。

               不達n,則縮小或擴大x等式不變。

            3.floor(x + y) 等于 floor(x) + floor(y) 或者是 floor(x) + floor(y) + 1

               x = floor(x) + {x}, y = floor(y) + {y},then

               x + y = floor(x) + floor(y) + {x} + {y},then

               floor(x + y) = floor(x) + floor(y) + floor( {x} + {y})

               and because  0<={x} < 1 and so do {y},so

              0<={x} + {y} <2,so floor({x} + {y}) = 0 or 1

             

            應(yīng)用:

               在程序中應(yīng)用之前,我先說下一個等式的證明

               celing(n / m) = floor( (n + m – 1) / m)

               這里n 、m都是整數(shù),而且m是正整數(shù)。

            證明:

                因為celing(n /m) – floor(n /m) = celing(n / m – floor(n / m))

                = celing(1/m * ( n – m*floor(n / m))) = celing((n mod m) / m)-------------(1)利用了上面兩條法則中Tips的第二點

                 同理可以得出floor((n + m –1) /m) = floor((n mod m + m – 1) / m)---------- (2)

               由(1)可以得到celing((n mod m )/ m) = 1

               由(2)可以得到floor((n mod m + m – 1) / m) = 1 (因為n mod m + m – 1 < 2 *m –1)

               所以可以一步步向上反推得到上面的公式。(其實這是一種分而自治的證明思想)

            具體在程序中的應(yīng)用例如:

            當你要在C++中寫如下代碼時候,而且n 、m都是整數(shù)。

            則celing(n * 1.0 / m) = floor( (n – 1) / m) + 1

            由于C++中除運算就是向下取整,所以

            celing(n * 1.0 / m) = (n - 1) / m + 1
            那么什么地方用得到,比如你在做大數(shù)運算時侯,要進行,分組,要8位一組
            然后算出一個可以分成幾組。可以直接利用這個原理,而不用再其進行函數(shù)的
            調(diào)用,比如你在閱讀人家的代碼時候、有時候就會這樣寫。

            下次你碰到這種代碼就會知道什么意思,和為什么能表示成這樣了。

            posted @ 2014-09-03 15:06 swp 閱讀(1148) | 評論 (0)編輯 收藏

                   現(xiàn)在已經(jīng)大四上學(xué)期了、然而在我看到的很多人其實是充滿了迷茫。根本不知道自己想要的是什么,也許這真的是教育的巨大失敗。實習這個話題、有人認為要早早的去做為好,因為才能更快的接觸社會經(jīng)驗,積累工作經(jīng)驗。在如今這個充滿浮躁、毫無信仰的社會、在我看來什么時候去實習并不重要,不要為了學(xué)分而實習,因為你根本不知道你想要的是什么,就去盲目的追尋,但是這有時侯確實又是矛盾的。因為在你搞清楚你最想要的是什么,搞清楚你最想成為一個什么樣的人并不是那么容易,因為感覺很多時候會欺騙你,只有你去嘗試了、專注的去做了,才會知道自己真正喜歡的是什么。但是其實這些早在你在找實習之前就應(yīng)該搞清除,你要了解你自己,而不是一頭扎入社會、盲目而無信仰,可悲的是,如今有很多人確實如此,于是他們總覺得生活不如意、不知道為什么而活著、不知道未來究竟在哪里。為什么說大學(xué)里面是犯錯的最好機會,我十分的贊成這種觀點,雖然現(xiàn)在我自身也不是特別有成就的人,但是這句話的卻是很有道理,大學(xué)里不是60分萬歲、不是只是找個女朋友回去,搞不好還要奉子成婚的大學(xué),大學(xué)是真正意義上的自我教育,更重要的是你要在大學(xué)里搞清除、想明白自己到底要做個什么樣的人并為此打好基礎(chǔ),在這個搞清楚前,你需要不斷的嘗試、嘗試各種方法。
                  以我自身為例、在上大一時候,因為高中一直看些黑客技巧的小伎倆,所以在報考大學(xué)時當時我的想法就是,一定要報計算機類的,因為我喜歡它,確實我喜歡編程、我喜歡數(shù)學(xué)。大一時候,我一直在想要怎么樣才能寫個軟件、我在想那么我得掌握什么、那時候沒有認識的學(xué)長、沒有人告訴我說,hello,你該怎么怎么辦、再怎么怎么辦、其實別人就算告訴你、在我看來也沒有多大用處。因為每個人自身的條件和環(huán)境不可能完全一樣,你不可能復(fù)制別人的成功來達到自己的成功,但是你可以學(xué)習別人成功方法,向他們看齊,所以大一一整年、我自己以為把算法數(shù)據(jù)結(jié)構(gòu)搞定了、我就能寫出牛逼的軟件、哈哈,天真!。于是那一整年都泡在算法數(shù)據(jù)結(jié)構(gòu)上、關(guān)鍵剛開始自學(xué)也是聽痛苦的,主要原因是沒有經(jīng)驗,竟然看了嚴蔚敏那本書,然后還沒有人可以指導(dǎo)下、倒是那是能自己把你面到圖部分的代碼全部自己搞定、費了好大一把盡。當時就覺得,應(yīng)該差不多了,可以去寫軟件了、、、唉、當時就是個菜逼。大一那時還十分積極很幸運的入選了ACM校隊,不過我們學(xué)校的acm水平太菜了,但是這個經(jīng)歷對我后來學(xué)習算法有很大的幫助。然后來到大二偶然看到網(wǎng)上的直播課程、還是免費的、于是當時就心血來潮的去學(xué)習了、學(xué)了好大一年,覺得學(xué)了很多,但卻沒有底子。這就是我第一次犯的最大錯誤,為什么,因為當時我也不知道該怎么寫軟件,所以就只有去嘗試、這個代價是花費了很長時間,我才明白這不是我想要的,但是我也學(xué)到了一些關(guān)于計算機的東西。接著迷迷糊糊的來到了大三,學(xué)了計算機網(wǎng)絡(luò)、編譯原理、操作系統(tǒng)等一些課程、其實當時我覺得這些課程這是他們的無聊枯燥、特別是網(wǎng)絡(luò)、寫得全都是背誦的,根本不知道怎么去實踐、也就是在這個過程我又開始了自學(xué)、開始探索該怎么學(xué)習這些課程、在探索的過程、就慢慢的才了解到這些課程的內(nèi)在、后來覺得這些課程真的是很有意思。但是呢,問題是等我探索完了、期末又來了,但是于此同時我對計算機和軟件這門學(xué)科了解的更深了,因為我知道怎么去學(xué)。在大三下的時候,我就已經(jīng)知道自己要怎么去學(xué)習這些課程、并且在這個過程我還自學(xué)了大量的數(shù)學(xué)知識、接觸了大量程序的東西、就是因為有這些嘗試、和真正的去做,我才越來越堅定自己能做什么,喜歡做什么,想要的是什么、其實前幾年也不是白上的,只是學(xué)校教的畢竟有限,更多的是要自我教育。
                  其實大學(xué)里,我們就應(yīng)該好好珍惜時間,最簡單的探索方法就是從大一一進來,你就去學(xué)習你感興趣的專業(yè)、最重要的課程都認真的去學(xué)習,在這個自學(xué)的過程、你一定能搞找到很多你本來看不清楚的東西,當然你還要有一顆不放棄的心,因為這個過程不是那么的容易,但是當你做到了你會越來越明白自己想要的究竟是什么,想成為什么樣的人,也許這個過程需要2年,也學(xué)需要3年,但請記住你在大學(xué),盡管去需找,需找你人生的意思!。所以大學(xué)是犯錯誤和實踐的最好的時間、不怕犯錯、就怕連錯誤都不會犯,然后迷失掉自己。為了實習而實習,而且你進入社會第一家公司,對我們其實是十分重要的!
                   之所以我打算工作一年期間考研究生(現(xiàn)在還在學(xué)習),一來是不打算再過度依賴父母,自己也掙點錢,二來是為了給自己3年來好好的沉淀下這些東西,研究生階段、我一定天天都是高三、因為我知道自己要的是什么。此文送給哪些還在迷茫中的人,送給哪些還在大學(xué)里的人,如果你明白了、永遠都不晚,努力去尋找,越早去尋找越好,也越能找到。
            posted @ 2014-09-02 00:14 swp 閱讀(230) | 評論 (0)編輯 收藏

            由于是數(shù)學(xué),所以要嚴謹。我們對于映射的概念直接摘抄來自同濟大學(xué)的高數(shù)課本。
            映射的概念:
            設(shè)X和Y是兩個非空的集合。存在一個法則T,使得X中的每個元素x按照法則T,在Y中都有一個唯一元素y與之對應(yīng)。
            那么T就稱為X到Y(jié)的映射。記為T:X-->Y.
            (1)X稱為T的定義域、Y稱為T的值域。而且y稱為x的像,x稱為原像。
            (2)函數(shù)、算子、都是映射的別名。
            Tips:
            為了更好的理解、其實學(xué)過圖論,就很好理解、可以把X看成起始點集合、Y看成終點集合、那么映射就是從起始點出發(fā)、都只有一條路徑可以到對應(yīng)的達終點(也就是說如果存在從某個起始點有兩條路徑可以到達不同的兩個終點,就不叫映射)。
            所以所謂的就是終點、原像就是起始點。

            滿射、單射、一一映射:
            滿射:在映射的概念下,不存在孤立的終點。(就相當于很多小島,分為左右兩半。左邊的每個小島都只有一座橋到達右邊的一個小島,不存在其它橋可以在去其它小島,然后右邊的小島都有橋連接,這就叫滿射)。
            單射:單射就是不存在兩個左邊的小島可以和右邊的同一座小島建立了橋。

            一一映射:同時滿足以上兩個
            嚴謹?shù)臄?shù)學(xué)定義:
            設(shè)T是集合X到Y(jié)的映射,諾T(X)=Y,即Y中任一元素均是X中某元素的像,則陳T為X到Y(jié)上的滿射。
            對任意x1、x2屬于X,x1 <>x2,必定有T(x1)<>T(x2),則陳T為X到Y(jié)上的單射。
            一一映射:滿足以上兩個。

            逆映射、復(fù)合映射:
            這兩個的數(shù)學(xué)定義就不講了、去翻翻高數(shù)課本。主要總結(jié)下從離散化的圖來理解的角度。
            逆映射:也就是在一一映射的基礎(chǔ)下,反客為主。把起始點變成終點、終點變成起始點。
            復(fù)合映射:復(fù)合映射說的是在映射的基礎(chǔ)下、對于第三方島嶼、右邊的島嶼都有建橋到第三方的島嶼(右映射到第三方,但第三方可能存在孤島)。則我們就可以把右邊看作中間點、左邊的島嶼也都有到第三方島嶼的路徑。(左邊映射到第三方
            ,但第三方可能存在孤島

            數(shù)學(xué)記號:
            映射T的逆映射記為T(-1)(y) = x.
            T1、T2兩個映射復(fù)合映射記為:T2 。T1
            上面句號是在正中間.
            posted @ 2014-08-29 23:44 swp 閱讀(639) | 評論 (0)編輯 收藏

            最近在練習算法、覺得有必要總結(jié)下C++這方面的知識,C++確實是復(fù)雜,but i love it。
            第一:運算符重載的基本應(yīng)用。第二:運算符重載于友原函數(shù)的關(guān)系。第三:結(jié)構(gòu)體于類關(guān)于運算符重載的區(qū)別。首先我需要普及下基本的知識:
            預(yù)備知識operator(操作符)、operand(操作數(shù))、表達式
            表達式是由操作符和操作數(shù)構(gòu)成的,而且一般每個表達式都有副作用,并且都有結(jié)果(關(guān)注結(jié)果和副作用)。什么意思?
            關(guān)于副作用的理解:其實就是在達到結(jié)果的這個過程中所做的一些事情,而這些事情產(chǎn)生了一些影響,但是不影響結(jié)果。
            好像有點繞、看看例子在理解吧。
            看例子:
            int a = 1,b=2,c; c = a + b;
            在這段代碼里面,c = a + b;就是表達式、其中 = 、 + 又稱為操作符、c、a、b又稱為操作數(shù)。其結(jié)果就是計算出了a+b的值,副作用沒有。
            又比如:
            cout << "Helloe" << endl;其中 <<是操作符、cout、"helloe"、endl是操作數(shù)。<<的結(jié)果是返回了ostream的引用,而副作用就是將"Helloe"輸出到屏幕。

            第一:運算符重載的基本應(yīng)用。
            看如下代碼:
             1 #include <iostream>
             2 
             3 using namespace std;
             4 
             5 class Point {
             6 private:
             7     double x,y;
             8 public:
             9     Point(double x = 0, double y = 0):x(x),y(y) {
            10         
            11     }
            12     Point operator+(const Point &p) const{//這種是最基本的方式、其本質(zhì)是做操作數(shù)調(diào)用operator+函數(shù) 
            13         Point temp;
            14         temp.x = this->x + p.x; 
            15         temp.y = this->y + p.y;
            16         return temp;
            17     }
            18     /*
            19     ostream& operator<<(ostream& out) {
            20         out << x << " " << y;
            21         return out;
            22     }
            23     */
            24     friend ostream& operator<<(ostream& out, Point & p);   
            25 };
            26 ///*
            27 ostream& operator<<(ostream& out, Point & p) {
            28     out << p.x <<" "<< p.y;
            29     return out;
            30 }
            31 //*/
            32 
            33 int main() {
            34     
            35     Point a(1,5);
            36     Point b(5,7);
            37     Point c;
            38     c = a + b;
            39     //c << cout << endl;
            40     cout << c << endl; 
            41     return 0;
            42 }
            如上代碼:
            注釋掉的先不用看,12--17行就是最基本的運算符重載、其調(diào)用在38行,本質(zhì)是:c = a.operator+(b);也就是調(diào)用做操作數(shù)的方法那么還要友元函數(shù)干什么呢?考慮下輸出,如果你想讓cout對象能自動輸出Point的對象如何半到。你很聰明一定想到重載<<運算符、yes!right!于是把operator<<作為成員函數(shù),你只能寫成上面注釋掉的哪樣,那么調(diào)用時,麻煩就來了、編程39行的樣子。尼瑪丫、真實變態(tài)、我是想讓它是cout << c << endl。搞得四不像了。是的就是因為這樣子不好用,所以我們要結(jié)合友元函數(shù)的技術(shù)和運算重載技術(shù)來實現(xiàn)40行的調(diào)用。好了重點來了!謹記之!
            tips:對于非成員函數(shù)的運算符重載,第一個參數(shù)就是左操作數(shù),第二個操作數(shù)就是右操作數(shù)。
            第二:運算符重載和友原函數(shù)的關(guān)系
            所以上面的友元函數(shù)的參數(shù)順序是cout對象的引用是第一個參數(shù)、Point對象引用為第二個參數(shù)。
            我們還要解決第二個問題,如何讓這個函數(shù)訪問Point對象的私有部分,只要在Point類中聲明,hello我是你的朋友啦、他的東西就是你的啦、你要怎么用怎么用,這才是朋友么!不、是基友!我認為應(yīng)該叫做基友函數(shù),哈哈。聲明格式就是加上friend和函數(shù)的聲明即可。
            tips:成員函數(shù)和非成員函數(shù)的運算符重載的區(qū)別就是,參數(shù)個數(shù)不一樣。成員函數(shù)中的左操作數(shù)不用體現(xiàn)出來(用this即可)、而非成員函數(shù)的左右操作數(shù)都要體現(xiàn)在運算符函數(shù)參數(shù)里面。
            第三:結(jié)構(gòu)體和類關(guān)于運算符重載的區(qū)別
            關(guān)于區(qū)別,其實只有一個,因為結(jié)構(gòu)體默認的權(quán)限是public、即其成員對外界都是可見的,所以其不需要友元函數(shù)來支持,但是其還是需要用非成員函數(shù)來重載<<比較方便、而不是用成員函數(shù)來重載<<.原因上面已經(jīng)說過了。注意這個原因不是友元這項技術(shù)體現(xiàn)出來的,而是成員函數(shù)和非成員函數(shù)體現(xiàn)出來的,友元技術(shù)知識用來支撐其在類中的應(yīng)用。、
            tips:對于結(jié)構(gòu)體,非成員函數(shù)的運算符重載方法,不需要聲明為友元函數(shù)。
            如下代碼:
             1 #include <iostream>
             2 
             3 using namespace std;
             4 
             5 struct Point{
             6     double x,y;
             7     Point(double x = 0, double y = 0):x(x),y(y) {
             8         
             9     }
            10     Point operator+(const Point &p) const{//這種是最基本的方式、其本質(zhì)是做操作數(shù)調(diào)用operator+函數(shù) 
            11         Point temp;
            12         temp.x = this->x + p.x; 
            13         temp.y = this->y + p.y;
            14         return temp;
            15     }
            16 };
            17 
            18 ostream& operator<<(ostream& out, Point & p) { 
            19     out << p.x <<" "<< p.y;
            20     return out;
            21 }
            22 
            23 
            24 int main() {
            25     
            26     Point a(1,5);
            27     Point b(5,7);
            28     Point c;
            29     c = a + b;
            30     cout << c << endl; 
            31     return 0;
            32 }
            posted @ 2014-08-29 16:31 swp 閱讀(2666) | 評論 (0)編輯 收藏

            這是我自己總結(jié)的cocos2dx,方便自己查看和復(fù)習。所以不一定適合您。
            //
            //  ImageScene.h
            //  sceneDemo
            //
            //  Created by sixleaves on 14-7-29.
            //
            //

            #ifndef __sceneDemo__ImageScene__
            #define __sceneDemo__ImageScene__

            #include "cocos2d.h"
            class ImageScene : public cocos2d::Layer
            {

            public:
                static cocos2d::Scene * createScene();
                virtual bool init();
                CREATE_FUNC(ImageScene);
            };

            #endif /* defined(__sceneDemo__ImageScene__) */
            /*
             總結(jié):
             知識點一:
             Scene場景類、Layer層的概念
             其實Scene是一對多得關(guān)系,一個場景類可以有多個Layer層。
             實質(zhì)上Scene就是由Layer層構(gòu)成的。他們的關(guān)系,你可以看成
             是樹的結(jié)構(gòu),而且Scene和Layer都繼承自Node類,所以其都
             能有addChild方法,所以Scene可以把Layer添加進去。
             
             知識點二:宏定義的兩個應(yīng)用
             1.在預(yù)編譯時期的過濾應(yīng)用(防御性措施)
             #ifndef __xxXXxxX_H__
             #define __xxXXxxX_H__
             insert #include code
             #endif
             這樣在當包含兩次時,就會過濾掉下一次包含。
             2.宏函數(shù)
             可以查看CREATE_FUNC的定義:
             如下
                    #define CREATE_FUNC(__TYPE__) \
                    static __TYPE__* create() \
                    { \
                    __TYPE__ *pRet = new __TYPE__(); \
                    if (pRet && pRet->init()) \
                    { \
                    pRet->autorelease(); \
                    return pRet; \
                    } \
                    else \
                    { \
                    delete pRet; \
                    pRet = NULL; \
                    return NULL; \
                    } \
                    }
            “\”號的意義:首先宏函數(shù)其實本質(zhì)上必須寫成一行,
                       而\只是在編程中對于不方便寫在一行的代碼的格式化
                       它告訴編譯器,我這一行還沒結(jié)束,把下面的繼續(xù)整合
                       上來成為一行。而在此處,這樣寫是為了提高可讀性。
            該函數(shù)的作用:創(chuàng)建指定對象,并且調(diào)用這個對象的構(gòu)造函數(shù)(init)。
             
            知識點三:C++中的多態(tài)
            對于同一個父類的類,調(diào)用的方法,取決于對象,這種形式的多態(tài)
            需要將父類中相應(yīng)地方法定義為virutal即可。其實這就是java
            中的盡量使用借口引用的原因、其就是為了適應(yīng)多態(tài),區(qū)別在于C++
            中比較啰嗦,而java是默認就是有virtual這種功能的。不用你再寫
            明。
            所以為了能夠在創(chuàng)建這個對象后調(diào)用其構(gòu)造函數(shù)init。需要重寫它
            這就是為什么其父類將其聲明為virtual的原因。至于createScene
            純粹就是工廠方法。
             
            */

            createScene主要還是分別調(diào)用Scene類和自定義layer類的工廠方法create創(chuàng)建對象,讓后將其添加到Scene對象中。
            //
            //  ImageScene.cpp
            //  sceneDemo
            //
            //  Created by sixleaves on 14-7-29.
            //
            //

            #include "ImageScene.h"
            USING_NS_CC;

            Scene * ImageScene::createScene() {
                auto scene = Scene::create();
                auto imageScene = ImageScene::create();
                scene->addChild(imageScene);
                return scene;
            }


            bool ImageScene::init() {
                Size size = Director::getInstance()->getVisibleSize();
                auto sprite = Sprite::create("CloseSelected.png");
                sprite->setPosition(size.width/2, size.height/2);
                addChild(sprite);
                return true;
            }
            posted @ 2014-07-30 15:49 swp 閱讀(300) | 評論 (0)編輯 收藏

            僅列出標題
            共10頁: First 2 3 4 5 6 7 8 9 10 
            婷婷久久综合| 久久香蕉国产线看观看精品yw| 77777亚洲午夜久久多喷| 99久久精品费精品国产一区二区| 狠狠色丁香久久婷婷综| 久久亚洲2019中文字幕| 韩国免费A级毛片久久| 久久久久久久波多野结衣高潮| 久久99热狠狠色精品一区| 久久久国产一区二区三区| 69国产成人综合久久精品| 久久本道久久综合伊人| 久久婷婷国产麻豆91天堂| 亚洲国产精品无码久久久蜜芽 | 久久久久99精品成人片牛牛影视| 婷婷国产天堂久久综合五月| 久久99中文字幕久久| 久久AV高潮AV无码AV| 精品水蜜桃久久久久久久| 97久久精品午夜一区二区| 久久精品无码一区二区WWW| 国产激情久久久久影院小草| 亚洲国产欧美国产综合久久| 久久夜色tv网站| 久久综合亚洲色一区二区三区| 久久精品视频网| 伊人久久精品无码av一区| 亚洲欧美日韩精品久久亚洲区| 无码人妻久久一区二区三区蜜桃| 亚洲欧美精品伊人久久| 91精品国产91久久| www.久久热| 久久美女网站免费| 99热精品久久只有精品| 伊人久久免费视频| 精品国产乱码久久久久久浪潮| 国产精品久久久久久久午夜片| 国产国产成人久久精品| 久久亚洲欧洲国产综合| 伊人情人综合成人久久网小说| 久久99热这里只有精品66|