2011年8月1日随笔档案 - FootPrint

2011年8月1日

C下不用中间变量交换两个变量值

1 #include<stdio.h>
2
3 void inplace_swap(int *, int *);
4 void main(){
5     int a = 10;
6     int b = 20;
7
8     inplace_swap(&a, &b);
9     system("pause");
10 }
11
12 void inplace_swap(int *x, int *y){
13     *x = *x ^ *y;
14     printf("%d, %d\n", *x, *y);
15
16     *y = *x ^ *y;
17     printf("%d, %d\n", *x, *y);
18
19     *x = *x ^ *y;
20     printf("%d, %d\n", *x, *y);
21 }

posted @ 2011-10-11 13:19 灰色客栈阅读(222) | 评论 (0) | 编辑收藏

Windows下使用命令行编译链接运行C程序

第一步，下载安装DEV-CPP软件；
第二步，找到找到安装目录下的bin文件夹；
第三步，bin文件夹目录添加到Path系统变量中即配置成功；

新建一个C程序源文件，设名字为hello.c

第四步，开始->运行->输入cmd回车，进入控制台，进入源文件所在的目录

输入命令gcc hello.c -g -o xxx，xxx即为编译连接后可运行的文件名
敲击回车键后，就可以运行编译后得程序：xxx.exe
在命令行中敲入xxx即可运行C程序获得运行结果。

在运行中很可能出现屏幕一闪而过的现象，这时候只要在程序的最后加上语句：system("pause");即可解决

posted @ 2011-10-10 23:51 灰色客栈阅读(873) | 评论 (0) | 编辑收藏

字符编码

转自：http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html 原作者：

阮一峰

今天中午，我突然想搞清楚Unicode和UTF-8之间的关系，于是就开始在网上查资料。

结果，这个问题比我想象的复杂，从午饭后一直看到晚上9点，才算初步搞清楚。

下面就是我的笔记，主要用来整理自己的思路。但是，我尽量试图写得通俗易懂，希望能对其他朋友有用。毕竟，字符编码是计算机技术的基石，想要熟练使用计算机，就必须懂得一点字符编码的知识。

1. ASCII码

我们知道，在计算机内部，所有的信息最终都表示为一个二进制的字符串。每一个二进制位（bit）有0和1两种状态，因此八个二进制位就可以组合出256种状态，这被称为一个字节（byte）。也就是说，一个字节一共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，从0000000到11111111。

上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码，一直沿用至今。

ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

2、非ASCII编码

英语用128个符号编码就够了，但是用来表示其他语言，128个符号是不够的。比如，在法语中，字母上方有注音符号，它就无法用ASCII码表示。于是，一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（二进制10000010）。这样一来，这些欧洲国家使用的编码体系，可以表示最多256个符号。

但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)，在俄语编码中又会代表另一个符号。但是不管怎样，所有这些编码方式中，0—127表示的符号是一样的，不一样的只是128—255的这一段。

至于亚洲国家的文字，使用的符号就更多了，汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。比如，简体中文常见的编码方式是GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示256x256=65536个符号。

中文编码的问题需要专文讨论，这篇笔记不涉及。这里只指出，虽然都是用多个字节表示一个符号，但是GB类的汉字编码与后文的Unicode和UTF-8是毫无关系的。

3.Unicode

正如上一节所说，世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。为什么电子邮件常常出现乱码？就是因为发信人和收信人使用的编码方式不一样。

可以想象，如果有一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，那么乱码问题就会消失。这就是Unicode，就像它的名字都表示的，这是一种所有符号的编码。

Unicode当然是一个很大的集合，现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如，U+0639表示阿拉伯字母Ain，U+0041表示英语的大写字母A，U+4E25表示汉字“严”。具体的符号对应表，可以查询 unicode.org，或者专门的汉字对应表。

4. Unicode的问题

需要注意的是，Unicode只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储。

比如，汉字“严”的unicode是十六进制数4E25，转换成二进制数足足有15位（100111000100101），也就是说这个符号的表示至少需要2个字节。表示其他更大的符号，可能需要3个字节或者4个字节，甚至更多。

这里就有两个严重的问题，第一个问题是，如何才能区别unicode和ascii？计算机怎么知道三个字节表示一个符号，而不是分别表示三个符号呢？第二个问题是，我们已经知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储来说是极大的浪费，文本文件的大小会因此大出二三倍，这是无法接受的。

它们造成的结果是：1）出现了unicode的多种存储方式，也就是说有许多种不同的二进制格式，可以用来表示unicode。2）unicode在很长一段时间内无法推广，直到互联网的出现。

5.UTF-8

互联网的普及，强烈要求出现一种统一的编码方式。UTF-8就是在互联网上使用最广的一种unicode的实现方式。其他实现方式还包括UTF-16和UTF-32，不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8是Unicode的实现方式之一。

UTF-8最大的一个特点，就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则很简单，只有二条：

1）对于单字节的符号，字节的第一位设为0，后面7位为这个符号的unicode码。因此对于英语字母，UTF-8编码和ASCII码是相同的。

2）对于n字节的符号（n>1），第一个字节的前n位都设为1，第n+1位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。

下表总结了编码规则，字母x表示可用编码的位。

Unicode符号范围 | UTF-8编码方式
(十六进制) | （二进制）
--------------------+---------------------------------------------
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

下面，还是以汉字“严”为例，演示如何实现UTF-8编码。

已知“严”的unicode是4E25（100111000100101），根据上表，可以发现4E25处在第三行的范围内（0000 0800-0000 FFFF），因此“严”的UTF-8编码需要三个字节，即格式是“1110xxxx 10xxxxxx 10xxxxxx”。然后，从“严”的最后一个二进制位开始，依次从后向前填入格式中的x，多出的位补0。这样就得到了，“严”的UTF-8编码是“11100100 10111000 10100101”，转换成十六进制就是E4B8A5。

6. Unicode与UTF-8之间的转换

通过上一节的例子，可以看到“严”的Unicode码是4E25，UTF-8编码是E4B8A5，两者是不一样的。它们之间的转换可以通过程序实现。

在Windows平台下，有一个最简单的转化方法，就是使用内置的记事本小程序Notepad.exe。打开文件后，点击“文件”菜单中的“另存为”命令，会跳出一个对话框，在最底部有一个“编码”的下拉条。

里面有四个选项：ANSI，Unicode，Unicode big endian 和 UTF-8。

1）ANSI是默认的编码方式。对于英文文件是ASCII编码，对于简体中文文件是GB2312编码（只针对Windows简体中文版，如果是繁体中文版会采用Big5码）。

2）Unicode编码指的是UCS-2编码方式，即直接用两个字节存入字符的Unicode码。这个选项用的little endian格式。

3）Unicode big endian编码与上一个选项相对应。我在下一节会解释little endian和big endian的涵义。

4）UTF-8编码，也就是上一节谈到的编码方法。

选择完”编码方式“后，点击”保存“按钮，文件的编码方式就立刻转换好了。

7. Little endian和Big endian

上一节已经提到，Unicode码可以采用UCS-2格式直接存储。以汉字”严“为例，Unicode码是4E25，需要用两个字节存储，一个字节是4E，另一个字节是25。存储的时候，4E在前，25在后，就是Big endian方式；25在前，4E在后，就是Little endian方式。

这两个古怪的名称来自英国作家斯威夫特的《格列佛游记》。在该书中，小人国里爆发了内战，战争起因是人们争论，吃鸡蛋时究竟是从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开。为了这件事情，前后爆发了六次战争，一个皇帝送了命，另一个皇帝丢了王位。

因此，第一个字节在前，就是”大头方式“（Big endian），第二个字节在前就是”小头方式“（Little endian）。

那么很自然的，就会出现一个问题：计算机怎么知道某一个文件到底采用哪一种方式编码？

Unicode规范中定义，每一个文件的最前面分别加入一个表示编码顺序的字符，这个字符的名字叫做”零宽度非换行空格“（ZERO WIDTH NO-BREAK SPACE），用FEFF表示。这正好是两个字节，而且FF比FE大1。

如果一个文本文件的头两个字节是FE FF，就表示该文件采用大头方式；如果头两个字节是FF FE，就表示该文件采用小头方式。

8. 实例

下面，举一个实例。

打开”记事本“程序Notepad.exe，新建一个文本文件，内容就是一个”严“字，依次采用ANSI，Unicode，Unicode big endian 和 UTF-8编码方式保存。

然后，用文本编辑软件UltraEdit中的”十六进制功能“，观察该文件的内部编码方式。

1）ANSI：文件的编码就是两个字节“D1 CF”，这正是“严”的GB2312编码，这也暗示GB2312是采用大头方式存储的。

2）Unicode：编码是四个字节“FF FE 25 4E”，其中“FF FE”表明是小头方式存储，真正的编码是4E25。

3）Unicode big endian：编码是四个字节“FE FF 4E 25”，其中“FE FF”表明是大头方式存储。

4）UTF-8：编码是六个字节“EF BB BF E4 B8 A5”，前三个字节“EF BB BF”表示这是UTF-8编码，后三个“E4B8A5”就是“严”的具体编码，它的存储顺序与编码顺序是一致的。

posted @ 2011-10-10 20:13 灰色客栈阅读(274) | 评论 (0) | 编辑收藏

Java中的一个有趣实验

一直很想试验一下对象创建时候两个类循环调用会用什么后果，今天做了一下，果然和想象的一下，下面贴出自己的实验代码：

实验中总共需要三个类：
第一个类：

1 public class Test_A {
2     public Test_A(){
3     Test_B b = new Test_B();
4     System.out.println("A is created!");
5     }
6 }

第二个类：

1 public class Test_B {
2     public Test_B(){
3     Test_A b = new Test_A();
4     System.out.println("B is created!");
5     }
6 }

上面两个类在实例化的时候都需要实例化对方，也就说这里形成了循环调用，下面看看测试类：

1 public class Test {
2     public static void main(String[] args) {
3     // TODO Auto-generated method stub
4     Test_A a = new Test_A();
5     }
6 }

大家现在可以猜一猜实验运行结果（昨天看到一片帖子也是说这个问题的，当时有人说不会出现循环调用）

一下是在Eclipse中的实验结果：

Exception in thread "main" java.lang.StackOverflowError
        at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)
    at Test_A.<init>(Test_A.java:4)
    at Test_B.<init>(Test_B.java:4)

整个输出窗口全部被占满

和预期的一样，真的产生了循环调用，并且出现了栈溢出异常！！

posted @ 2011-10-10 10:45 灰色客栈阅读(365) | 评论 (0) | 编辑收藏

Java实现简单的List

节点代码：

1 //定义数据结构
2 public class LinkNode {
3     int value;
4     LinkNode next;
5
6     public LinkNode(int value){
7     this.value = value;
8     }
9 }

以上是定义的链表节点，可以在新建节点的时候赋值

链表节点：

public class MyList {
    //定义首节点
    LinkNode first;

    //定义尾节点
    LinkNode last;

    //定义长度
    int length = 0;

    public MyList(){
    first = null;
    last = null;
    }

    public MyList(LinkNode node){
    first = node;
    last = node;
    length++;
    }

    //添加节点
    public void addNode(LinkNode node){
    if(first == null){
        first = node;
        length = 1;
    }
    else{
        last.next = node;
        last = node;
        length++;
    }
    }

    //删除指定节点:遍历链表，将遇到的第一个和指定节点相同的节点删去
    public void deleteNode(LinkNode node){
    if(first == null){
        return;
    }

    else if(first.value == node.value){
        first = first.next;
        length--;
    }
    else{
        //如果链表不为空，要删除也不是第一个
        LinkNode temp;
        System.out.println(node.value);
        for(temp = first; temp != null ;temp = temp.next){
        if(temp.next.value == node.value){
            //如果下一个就是最后一个
            if(temp.next.equals(last)){
            last = temp;
            length--;
            return;
            }
            length--;
            temp.next = temp.next.next;
            return;
        }
        }
    }
    }

    public int getLength(){
    return length;
    }
}

以上是链表的具体实现，这里只实现了很简单的三个功能：添加节点，删除指定节点，获取链表长度。

接下来是测试代码：

public class Test {
    public static void main(String[] args) {
    LinkNode node = new LinkNode(3);

    MyList list = new MyList(node);

    list.addNode(new LinkNode(3));
    list.addNode(new LinkNode(6));
    list.addNode(new LinkNode(4));
    list.addNode(new LinkNode(7));
    list.addNode(new LinkNode(2));

    listDisplay(list);

    list.deleteNode(new LinkNode(3));
    listDisplay(list);
    }

    public static void listDisplay(MyList list){
    int i = 0;
    int length = list.getLength();
    LinkNode temp;
    for(temp = list.first; i < length; temp = temp.next, i++){
        System.out.print(temp.value + " ");
    }
    System.out.println();
    }
}

以下是输出结果：

3 3 6 4 7 2

3 6 4 7 2

程序有待改善的地方：
1.完善链表功能，比如插入功能（和添加什么的大同小异）；
2.加强功能实现，可以通过一定的手段消除First的特殊性，使得实现更加简单；
3.可以使用泛型，是的链表的存储不局限于Integer类型；

posted @ 2011-10-10 10:29 灰色客栈阅读(601) | 评论 (0) | 编辑收藏

Android之Uri

摘要: 一、Uri的含义在Android中，为了使用数据集中管理模式，使用了ContentProvider来进行数据管理，在使用ContentProvider进行数据交互时就需要用到Uri。为了让客户端程序能够使用你的数据，你必须要定义一个公开的Uri，它由一些固定格式的文字组成，可以分成下面几个部分： A: schema，表达的意思是使用ContentProvider来... 阅读全文

posted @ 2011-10-07 19:31 灰色客栈阅读(2550) | 评论 (0) | 编辑收藏

C#之委托

从一开始接触C#到现在，委托对我来说都是一道坎，曾经想要避开，可是每次写、看C#程序都避免不了接触这玩意儿，每次都会觉得很憋屈！所以这几天想下点苦功夫一下子彻底搞懂它，下面说说自己的见解吧~~

一、什么是委托
对于这个词，一开始接触的时候很陌生，这也导致了我的畏惧心理，后来学习设计模式的时候知道了委托模型，当时也不怎么搞的明白，现在冷静下来自己看看，这里也算入门了。委托，说白了就是一种相当于c++函数指针的东东（如果对C++函数指针不熟的话这就等于白说了啊，还是看下面的例子吧！）~
首先看一下委托的额声明例子： public void delegate Delete_Delegate(string args);委托的声明中有两个东西是非常重要的，第一个是void，也就是这个委托可以注册（代表）的函数的返回值，其次便是args，这个是该委托可以注册（代表）的函数所使用的参数。换句话说，所有的以string为参数，以void为返回值（这里暂时这么说）的函数都是可以通过这个委托进行注册的！
我想看到这个大家就应该很有感触了，一个方法，除了方法名，最能标志它的东西无非就是返回值和参数，至于修饰符，后面再提，所以委托可以说是抓住了方法的核心成分，置于方法名么，这个自然好理解，如果把方法名也通过委托表现出来，那就不需要委托的存在了，其实后面还有一个用处，那就是多播委托~后面再讲

二、委托的使用
委托的使用分为三个步骤：1.委托声明 2.委托注册 3.委托调用a. 委托声明，举个例子：public void delegate Print(string name);解说同上！

b. 委托注册：现在假设有一个函数：
    public void speakEnglish(string say){
        Console.WriteLine(say);
    }
注册方法：Print english = new Print(speakEnglish);
解说：委托其实可以被看作是一个特殊的类，很明显，这里声明的就是该类的实例english，我们再注意一下这里的构造函数所使用的参数，它是一个方法名，该方法必须和委托声明的方法签名一致，否则会抛出异常；上面只是一种注册方式，还有其他便捷的方法~

c. 委托调用：english("hello"); 这个时候控制台便会输出hello字符，委托调用成功！

#########################################华丽丽的分割线#############################################

以上所描述的是最最基本的委托使用过程，接下来引申开来，继续深入

三、多播委托
多播委托对于委托实现其价值来说真的是很重要的，比如在事件监听中的使用。
多播委托的特点：
1）多播委托，顾名思义，就是说可以通过委托一次调用一个以上的方法；
2）多播委托声明时必须返回void，否则会抛出异常；
3）多播委托一旦遇到一个函数抛出异常，则会停止执行剩余的函数；（这个是可以解决的）
这里也可以体会到为什么不需要把方法名通过委托表现出来的原因。

下面举一个多播委托的例子：延续上面的例子（注：多播委托和一般委托的声明并没有什么决定性区别，唯一要注意的就是上面说的特点2）
假设还有一个方法：
    public void speakChinese(string say){
   Console.WriteLine(say);
    }
下面需要同时调用两个方法，那么怎么通过多播委托实现呢？
    Print print = new Print(speakEnlish);
    print += speakChinese;
    print("Hello, 中国！");
这样的话控制台上就会出现两边Hello,中国字符。
解释：1）很明显，多播委托不管注册多少方法，其方法签名一致的要求是不可以更改的！
        2）注册的时候首先声名委托的实例，然后可以通过“+=”运算符添加（注册）更多的方法！同理可知，也可以通过运算符“-=”取消注册；
   3）注册完毕后，一旦如同一般委托通过委托实例传入参数则所有注册过的方法都会接收参数运行一遍！并且是没有执行顺序的！
通过3）可以解释为什么返回值必须是void，甚至返回值是同一个类型都不可以！因为多播委托中注册的方法是一起调用的，如果有返回值，比如一个返回1，一个返回2，那么就会出现一个函数（委托）返回多个值的情况，总会出错！所以必须为Void.

到这里，我想具体什么是委托，怎么使用委托基本上比较清楚了，下面我最最关心的就是到底委托会被用在哪些地方呢？委托是C#中比较独特的一个技术，存在即是真理，它的优点在什么地方？（很不幸，我C++没学好，关于C++函数指针的有点也没参透，所以不能迁移过来）

####################################委托的能力######################################
大家在使用集合时，一定使用过Sort类似的方法，这个方法就是用来对集合中的元素进行排序的，对于一般元素，比如int等等，它内部就嵌有比较方法在里面，然而，很多时候我们需要比较的往往不是这么简单的东西，很多时候我们要比较的是我们自己定义的类型。而Sort方法中也有一个构造函数，是需要我们自己传入比较函数的，这里就是一个使用委托的绝佳范例。下面引用的例子来自《C#高级编程（第6版）》（有兴趣的话可以去看看，书不错，就是厚了点）
程序1：

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4
5 namespace Wrox.ProCSharp.Delegates
6 {
7    class Employee
8    {
9       private string name;
10       private decimal salary;
11
12       public Employee(string name, decimal salary)
13       {
14          this.name = name;
15          this.salary = salary;
16       }
17
18       public override string ToString()
19       {
20          return string.Format("{0}, {1:C}", name, salary);
21       }
22
23       public static bool CompareSalary(object x, object y)
24       {
25          Employee e1 = (Employee)x;
26          Employee e2 = (Employee)y;
27          return (e1.salary < e2.salary);
28       }
29    }
30 }

这个Employee类里面定义了一个比较方法，CompareSalary，这个方法就是等会儿需要注册委托的方法

程序2：

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4
5 namespace Wrox.ProCSharp.Delegates
6 {
7    delegate bool Comparison(object x, object y);
8
9    class BubbleSorter
10    {
11       static public void Sort(object[] sortArray, Comparison comparer)
12       {
13          for (int i = 0; i < sortArray.Length; i++)
14          {
15             for (int j = i + 1; j < sortArray.Length; j++)
16             {
17                if (comparer(sortArray[j], sortArray[i]))
18                {
19                   object temp = sortArray[i];
20                   sortArray[i] = sortArray[j];
21                   sortArray[j] = temp;
22                }
23             }
24          }
25       }
26    }
27 }

这个类里面声明了一个委托，可以看到这个委托和上面Employee类里面的方法签名是一样的，也就是说可以通过这个代理注册上面的CompareSalary方法

程序3：

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4
5 namespace Wrox.ProCSharp.Delegates
6 {
7
8    class Program
9    {
10       static void Main()
11       {
12          Employee[] employees =
13          {
14            new Employee("Bugs Bunny", 20000),
15            new Employee("Elmer Fudd", 10000),
16            new Employee("Daffy Duck", 25000),
17            new Employee("Wiley Coyote", (decimal)1000000.38),
18            new Employee("Foghorn Leghorn", 23000),
19            new Employee("RoadRunner'", 50000)};
20
21          BubbleSorter.Sort(employees, Employee.CompareSalary);
22
23          foreach (var employee in employees)
24          {
25             Console.WriteLine(employee);
26          }
27          //for (int i = 0; i < employees.Length; i++)
28          //   Console.WriteLine(employees[i].ToString());
29       }
30    }
31 }

我们看一下这里是怎么使用委托的！
首先声明了一个Employee数组，目标是对里面的元素尽心排序，我们看到，排序使用的方法是静态的Sort()方法，传入了一个数组和一个方法名，而在Sort()方法的参数列表里面大家可以看到，与方法名对应的位置是委托的实例，也就是说，我们把比较的方法通过委托传给了比较函数，这样，我们就能够通过改变比较的方法来实现比较我们自己定义的类型的目的！
个人感觉这样的实现很方便，尤其是将比较函数分离出来，这样符合程序的“开闭原则”，将需要变化，可能变化的部分剥离了出来~~

当然，委托的能力不是这样一个例子可以说清楚的，况且这里还没有列出多播委托的例子，在窗体事件中每个多播委托可以实现一个事件激发多个监听者的功能，所以说到底委托有什么好处，该怎么使用，都需要多多实践才能更多的领悟~

接下来还有些东西值得侃一侃：
1.委托之匿名方法：
委托不但可以为已经存在的方法注册，而且在编辑过程中可以直接添加一个匿名方法，换句话说，就是临时写一个方法放入注册列表中，下面是一个示例,延续上面的案例：
   Print print = delegate(string say){
   Console.WriteLine(say);
    }
这里注册就不是一个方法了，而是一个代码块，关键字是delegate，这是不能更改的，后面的传入参数以及里面方法的返回值（如果有返回值的情况）必须要和委托声明的一致！
这里我有一个疑问，这种匿名方法的委托使用是不是可以用在多播委托中？按常理应该是可以添加的，那么怎么取消注册呢？（没有方法名的情况下是不可能使用-=的嘛~）

2.委托

λ表达式

：

表达式是C#3.0新提供的语法，用于委托类型以简化代码，事实上，

表达式

就是委托形式的一种符号表达形式，下面是一个示例：

上面的匿名方法的例子是可以这么用表达式写的：

    Print print => (say) {
   Console.WriteLine(say);
    }

上面的表达式很奇怪吧？say这个变量没有实现声明就开始使用了对吧？解释如下：
其实say是声明过的，在哪里声明的呢？对，没错，就是第一次使用的时候声明的，但是很明显，这里根本不像变量声明啊！根本就没有指出类型嘛，这就是委托的独特之处，在声明委托的时候就已经指出了参数的类型，在这里表达式是专门代替委托而存在的，也就相当于在这里指出了say的类型！

下面再看一个例子就知道表达式和委托的关系了：
委托声明：public delegate bool Predicate(int object);
看下面的使用方法：

Predicate p1 = x => x>5;

list.findAll(

x => x>5

);
第二种使用方式相当于：

list.findAll(

delegate(int x){return x>5}

)

;
对比上面两条语句，是否有所感悟？

3.委托之协变与抗变
这个我想也不太常遇到，其实就是委托的参数与返回值和父类与子类之间的一种转换，这里就不罗哩罗嗦了~~

写写写写发现有点像是整理，不过想说的也基本上说在这里了，欢迎留下意见，也欢迎留下问题互相交流~

posted @ 2011-09-01 15:30 灰色客栈阅读(237) | 评论 (0) | 编辑收藏

Android项目导入出现问题解决方案

在往自己的Eclipse/MyEclipse中导外部Android项目的时候有时候会出现一些问题，如下：

很正常的工程现在连导入包都会出错，整个项目出现大面积的错误，很明显，肯定是工程找不到这个包。

现在看一下这项目的树:

再看一个很正常的项目的树：

这样一对比是不是发现问题了？正常的Android项目比不正常的项目多了一个Android2.2的包！

解决方案：
Android右击 -> Build Path -> Configure Build Path
在侧边栏里面选中Android

选中一个Project Build Target，这个选择项就是对应上面缺失的文件，选中后点击右下角的Apply
这时候错误项目里面就会出现Androidx.x，项目回复正常

可能出现的问题：
点击Apply后错误项目没有反应，这时候其中一种可能就是：项目的属性是只读的！（我的电脑有一次中毒，所有文件都被改成了只读）
解决方案：去workspace中选中文件，右击，属性，将只读去掉，点击确定！然后到集成开发环境中右击项目，刷新，再按照上面的操作步骤走一遍应该就会OK！

再提一个联系不是很紧密的问题：有时候R文件会莫名其妙的不见，给大家提供两种手段，可以试试~
1）选中项目，在菜单栏里点击Project，然后点击Clean...；
2）选中项目右击，点击Android Tools，然后点击Fix Project Properties，刷新；
记得将Project里面的Build Automatically勾选上！

R文件丢失的情况下千万不要做两件事：
1）自己新建一个R文件；
2）从别的项目里面拷贝R文件，就算是你以前备份的同一个项目里面的R文件都不可以这么做
R文件是项目自动生成的，是每个项目自己所独有的，不可以

posted @ 2011-08-29 17:49 灰色客栈阅读(5322) | 评论 (0) | 编辑收藏

使用Hudson持续集成Android项目

摘要: Hudson是一款持续集成引擎，架构在Subversion等版本控制工具上，依靠构建工具对项目进行集成构建，并且可以根据用户需求提供相应的反馈，比如发邮件，总的来说是比较实用的。这几天在老师的要求下使用了Hudson，在纯JAVA项目的情况下使用MAVEN配置起来还算简单，无奈项目的客户端是Android平台的，在纠结了N天后还是配置不成功，最后改用Ant, 整个过程还是比较简单，除了build.... 阅读全文

posted @ 2011-08-01 00:01 灰色客栈阅读(2710) | 评论 (2) | 编辑收藏

C下不用中间变量交换两个变量值

Windows下使用命令行编译链接运行C程序

字符编码

Java中的一个有趣实验

Java实现简单的List

Android之Uri

C#之委托

Android项目导入出现问题解决方案

使用Hudson持续集成Android项目

导航

统计

常用链接

留言簿

随笔档案

文章档案

搜索

最新评论

阅读排行榜

评论排行榜