shu equical to learn; ha equical to detach and ri is transcend. During the Shu phrase, the student builds the technical foundation of the art. It also implpies a loyalty or persistence in a single instructor; Ha is the second stage of the process. It means that the student breaks free from the traditions of the instructor to some extent; Ri means to go beyong, in this stage, the student is no longer a student in the normal sense, bu a practioner. The practioner must think originally and develop from background knowledge original thoughts about the art and test them against the reality of his or her background knowledge and conclusion as well as the demands of everyday life
这个傻X改的注册表键值有：

HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer\AboutURLs\
xp = '垃圾网站'

HKEY_CLASSES_ROOT\CLSID\{871C5380-42A0-1069-A2EA-08002B30309D}\shell\OpenHomePage\Command\
@="垃圾"

HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\
"start page" = "about:xp" #/usr/bin/env/ python                                             （1）起始行


"this is a test module "                                              （2）模块文档


import sys
import os                                                                        （3）模块导入


debug = True                                                                 （4）全局变量的定义（尽量避免）

class FooClass （object）：
       "Foo class Doc"                                                     （5）类定义 （若有）
    pass
    .... ......





def test():
       "test function doc"                                                （6） 函数定义（若有）
 .......................... 


if  __name__ == '__main__'：                                   （7）主程序
      test()
 

1.在继承方面，C++中的名字覆盖规则（子类覆盖父类的名字）在C#2.0中并不成立。在C#中提供了 new/ virtual/ override等关键字

    class B
    {
        public virtual void f()
        {
            Console.WriteLine("B::f()");
        }
    }

    class D : B
    {
        public void f(int i)
        {
            Console.WriteLine("D:f(int i)");
        }
    }

    class E : D
    {
        public override void f()
        {
            Console.WriteLine("E:f()");
        }
    }

D d = new E();
d.f() 仍然是可见的，且调用 E::F();

2.C#中的嵌套类是外部类的友元，外部的private 成员对它也是可见的， C#中没有java的inner class的概念，等价于java中的 static class。而C#中的static class 为静态工具类，只含有static 方法，见9.。

class A
{
int _i;

class B
{
B(A a)
{
a._i = 10;//访问
}

}//end B

}//end A

3.C#在构造期间 调用virtual 函数会被 转发到类继承体系中的最远端， 区别于C++。

4.利用sealed, 或者new 可以终止掉成员函数virtual 关系的延续。

    partial class Program
    {
        static void Main(params string[] args)
        {
            B b;
            D d;

            E e;

            e = new E();

            b = d = e;

            b.f(); // B::f
            d.f(); // E::f
            e.f(); // E::f
        }

    }

    class B
    {
        public virtual void f()
        {
            Console.WriteLine("B::f()");
        }
    }

    class D : B
    {
       
        public new  virtual void f()
        {
            Console.WriteLine("D:f()");
        }
    }

    class E : D
    {
        public override void f()
        {
            Console.WriteLine("E:f()");
        }
    }


5.C#构造函数的ctor initializer list中可以出现的只有 this(...), base(...)

6.C#属性不可以作为 out，ref 参数传递；out ,ref两者在函数重载中的效果等价:  void f(out int i)， 与 void f(ref int i) 不能构成重载， 但与void f(int i)去构成重载

7.C#关键字partial 用于 类的定义放到 多个.cs文件中：a.用于自动代码生成；b.用于将某个类的多个嵌套类分开，使达到一个文件一个类的原则。

8.C#函数的变参 使用 params ， 而不是 (...)。

9.C#中的static 类相当于 只含有static 方法的工具类， 且为sealed， 不能含有非静态数据成员

10. C#中const成员默认为 static的，readonly成员可以有static或者非static的， 但只能在ctor中修改其值。

11.属性中的 set / get 其中一个且仅一个是可以重新指定 访问权限的,但权限必须低于属性本身指定的。
public int I
{
private set
{
.....
}

get
{
return 0;
}
}


**协变 与 逆协变？

  class B
    {
    }

    class D : B
    {
    }

    class A
    {
        public virtual void f(B b)
        {

        }
    }

    class A1 : A
    {
        public override void f(D b) //error， 错误的override
        {
            base.f(b);
        }
    }

 不久，你就要毕业、走上工作岗位了。这是一个漫长岁月，将近四十年的职业生涯。
 
 
作为父辈、一个经历了多年职业生涯的“过来人”，说几句“老生常谈”，对你今后的职业生涯应该有所帮助。
　　
关于找工作一下子找到自己喜欢的工作很不容易，更何况眼下就业形势那么严峻。因此，你要有思想准备，从不那么理想的事情做起。这样你的就业渠道就宽了，就业压力就小了。虽然每个人的理想各不相同，但通向理想的努力途径却是相同的。你不能马上得到理想的工作，并不是没有机会，而在于你并没有完全准备好。所以，即使你没找到理想的工作，也不要气馁，继续储备力量。早晚有一天，它会找到你。
　　
很多应届生都苦恼自己没有（工作）经验，抱怨用人单位过于挑剔。其实，用人单位挑剔的是你缺乏解决问题的经验。试想，一个连简历都不认真写的应聘者，又怎么能为别人做好差事呢？一个盲目自大、夸夸其谈的人又如何能虚心跟别人配合呢？
　　
不要“萝卜快了不洗泥”，而要审视你所求职的单位。上该公司网站看一看，了解一下该公司经营什么产品服务、销售额如何、在行业领域中的地位和目前的处境。不要只管看招聘广告，见了面对该公司的事情“一问三不知”。
　　
面试是相互的。他们面试你，你也在面试他们。从接电话、前台人员接待、面试官的精神状态和行为举止，到你所看到的办公环境等，都能感受到那家单位的文化、思想。不要因为公司小、没有名气就轻易放弃。重要的是那家公司的事业、公司领导者的品德和能力以及员工们的精神面貌。
　　
关于工作后
　　
　　工作以后，你要学会与人和睦相处并建立良好的人际关系。
　　
　　在学生时代，除了老师外，周围的人，基本上都跟你是同龄人，而在工作岗位，你将遇到更多的比你年龄大的前辈或长辈；在学校里，你和同学们都是平等的，就算有老师、有班干部等差异，但比起工作中面对的“客户”及上司来说，学校里的地位差距，基本上是微乎其微。
　　
　　礼仪是人际关系的“润滑油”，你一定要好好掌握。比方说，与人见面要主动打招呼；进门、上电梯要注意礼让别人；长辈或者上司找你谈话时，要站起来表示尊敬；接打电话时，要等对方挂电话后自己再放下电话，等等。千万不要小看这些琐碎的“小事”，你在这些地方的表现，将在很大程度上给人一个深刻的印象。
　　
　　有些事情与其说是礼仪，倒不如说是素质。比方说，用完工具要把它放回原处；复印机的纸用光了你要主动把它补充好；不要去破坏工作环境，相反的如果看到工作环境比较零乱，要主动收拾，而别计较是谁弄乱的。我知道对于你们这些独生子女来说，做到这些是很困难的，但是，再困难也要学会这样做，因为这就是工作。
　　
　　你要学会听、问。上司给你布置工作时要认真听，并做笔记。之后最好把重点复述一遍。离开时问一句：您还有什么要嘱咐的吗？对其他同事要谦虚，即便自己已经懂了，如果人家还再教你，也要认真听讲。记住每一个教过你知识、经验、技能的人，当别人表扬你做得好时，要告诉他们是跟谁学的。
　　
　　不要去打听、议论别人的隐私。跟同事说话时不要正对着人家的电脑屏幕，除非人家主动跟你说，或者让你看。远离是非之地、远离牢骚满腹的议论，因为它无异于你的成长，反而使你丧失信心。要主动接近那些积极向上、心态良好的同事，以他们为榜样，这样你进步的速度就会加快。
　　
　　要主动做别人不愿意做的事情，比如，整理办公室，做会议记录、维护客户联络表等。努力记住跟你打交道人的姓名。就算没事儿，也别忘记打个招呼或发邮件问候一下。久而久之，他们也会同样记住你，并在你需要的时候帮助你。工作中有良好的人际关系，不仅可以使你如虎添翼，还将使你人生的三分之一保持愉快。
　　
　　工作之后，你将得到工作报酬，这是跟你以往任何时期最大的不同。过去，你一直是依附父母的收入，维持你的生活、学习和成长。今后你通过自己的工作报酬，维持你的生活，开拓美好的人生。为此，你要学会热爱工作、珍惜工作，学会工作。
　　
　　别小看任何工作！因为“没有普通的工作，只有普通的员工”。即便是简单计算，久而久之你就可以把单纯的数字连成线、构成面，最终看出走向、趋势。同时，任何工作都是可以改善和创新的。比方说，更短时间、更少的代价（费用）、更高的质量、更美的效果。
　　
　　你要认真对待工作。你的工作结果，将反映你的性格和素质。在做一件工作时，你不仅要听取上司的指示，还需要考虑工作结果受益者的感受。虽然永远不可能达到完美，但你只有不断地追求它，你才能得到客户和上司的赏识。
　　
　　另外，别太计较收入或职位的高低。对你来说，积累工作经验和技能是今后几年最重要的事情。不要拒绝“额外”的工作，因为这些额外工作可以拓宽你的职业领域；也不要害怕挑战性工作，正是这些“挑战”，才构成了你职业生涯的“阶梯”。当你的本领已经到了脱颖而出的地步，收入和职位自然会被提升。
　　
　　还有，养成“守时”、“守信”、“讲原则”的习惯，将使你终生受益。做不到的事情就不要轻易地答应。如果答应了，无论如何都要做到。“讲原则”就是守法、公私分明。不要做违法的事情，如果有人打着维护公司利益的旗号，让你做违法的事情，你最好想办法让他拿出书面指示。不要贪公家的小便宜。就算很多人都这样做，也不要同流合污。贪小便宜的人，目光短浅、意志薄弱，注定做不了大事。久而久之，就会养成投机取巧、好逸恶劳、不思进取进而丧失人格，最终要“吃大亏”。
　　
　　关于职业生涯的必要技能
　　
　　有些技能可以跟师傅或从书籍中学到。但是，像“关心、体贴”，“联想、构思”等意识和习惯，只能靠自己的悟性和实践来掌握。所以，你要学会反省、静心思考，学会站在他人的立场检讨自己的言行；同时，要做到更宽的联想，更缜密的构思，不仅需要增加见识、扩展思路，更要解放思想。因此，要学会自我否定、超越“传统”，批判地接受现实的一切。要能听取各种不同的声音和见解，并努力地理解他们为什么会有那种思想。学会用具体、形象的东西，来理解和解释抽象和虚拟的东西，对提高构思水平很有帮助。
　　
　　要努力掌握、精通一门外语。因为掌握一门外语等于打开了一个新世界。不过要记住，外语只是工具，重要的还是扩展思路，提高思维水平。
　　
　　电脑、网络将成为今后工作的必要工具。要学会利用电脑、网络，并经常更新这方面的知识。对于其他数码相关技术，比方说、摄影和视频表现技术，也是需要留意，因为这也是未来的表达方式。虽然未来的工作发展机会，更多地产生于虚拟社会。但也不要痴迷于电脑和网络、不能自拔。要能进得去出得来，否则，将使你成为高科技的奴隶。适当地多走走、看看大自然和人文生活，有助于你的陶冶身心、拓宽心胸。
　　
　　注意锻炼身体，最好能喜欢上一种能够使你出汗的体育运动。因为体育运动不仅能健身，还能释放压力、净化心灵。
　　
　　最后，你要学会自我更新。过去学习有老师教你，而今后你将自己学习应对所有变化。虽然说“开卷有益”，但还要少看杂志、多看书，别忘了你的理想。自觉地学习、借助前人的经验和别人的智慧，扩展自己、提升自己，对你今后的职业生涯大有好处 对于__int64，为了防止不正确的截断输出，即全部显示为0.

可以使用%I64d 有符号整数 或者 %I64u 无符号整数 来表示

printf("the number is  %I64u \n",number);
2.1 实现如下编码算法，对于重复2-9次数的字符，用两个数字表示，即NX（其中N为重复的次数，X为重复的字符，下同），超过九个则先输出9X，然后处理剩下的字符。对于连续的不重复的字符，则两边加1来封字符串。如果被封的字符串其中有数字为1，则用1来转义。    示例： AAAAAABCCCC -> 6A1B14C,  12344 -> 11123124。。。（下面的框架是用C++语言写的。你可以用你熟悉的语言。）
void encode (const char* text, char* dest)
text 为需要编码的字符串，dest表示编码输出的目标空间，而空间足够大。

#include <iostream>

#include <stdio.h>


const int N = 9;
using namespace std;




void encode (const char *text, char *dest)
{
    char const *pCur = text;

    while(*pCur != '\0')
    {
        if ( *pCur != *(pCur+1) )
        {
            *dest++ = '1';           
            while( (*pCur != '\0') && *pCur != *(pCur + 1) )
            {
                *dest++ = *pCur++;
                if (*(dest-1) == '1') *dest++ = '1';
            }
            *dest++ = '1';
        }
        else
        {           
            int count = 1;
            while( *pCur && *pCur == *(pCur + 1) )
            {
                ++pCur;
                ++count;
                if (count == N)
                {
                    break;
                }
            }
            ++pCur;
            *dest++ = '0' + count;
            *dest++ = *(pCur-1);
        }

        *dest = 0;
    }
}


void main (void)
{
    const char* s="AAAAAABCCCC12345DDDDDDDDDDDDDDDDDDDDDD1DD12344XXX11123433677777";
    char d[100]="";

    encode(s, d);
    printf("Google\n");
    printf("text=%s;\ndest=%s;\n",s,d);

}


void swap(int& a, int& b)
{
    int c = a;
    a = b;
    b = c;
}
int partion(int a[], int p, int r)
{
    int i = p-1;
    int x = a[r];
    int j ;
    for (j = p; j <= r-1; ++j)
    {
        if (a[j] <= x)
        {
            ++i;
            swap(a[i], a[j]);
        }
    }
    swap(a[i+1], a[r]);
    return i + 1;
}


void quicksort(int a[], int p, int r)
{
    if (p < r)
    {
        int q = partion(a, p, r);
        quicksort(a,p, q-1);
        quicksort(a,q+1, r);
    }

}
int main()
{
    int a[7] = {7,6,5,1,3,2,4};

    quicksort(a, 0, 6);
   
    for (int i = 0; i < 7; ++i)
    {
        cout << a[i] << "  ";
    }
    cout <<endl;
   

    return 0;
}


long    s;

__declspec(naked) long __stdcall atomic_postdecrement_up(long volatile * )
{
    __asm
    {
        mov eax, -1


            mov ecx, dword ptr [esp + 4]

        mov dword ptr [s], ecx

            xadd dword ptr [ecx], eax

            // Since this is post-decrement, we need do nothing, since the previous
            // value is in eax

            ret 4
    }
}

#include <stdio.h>

int main()
{
    for(long i = 0, j = 10; i < 10; ++i)
    {
        int k;

        k = atomic_postdecrement_up(&j);

        printf("0x%08x\t0x%08x\n", (unsigned long)&j, s);

        printf("%d, %d, %d\n", i, j, k);
    }

    return 0;
}