C++博客-Sunshine Alike

SVN的一点使用介绍

Sunshine Alike — Fri, 30 Jul 2010 06:24:00 GMT

SVN：   subversion. Is a version control system, open source, and free.

通常有两种使用使用模式：
   Lock-modify-Unlock   独占式，代表VSS
   Copy-modify-Merge   并行式，CVS/SVN
方式1简单易行，但是不能支持多人协同工作，其它人在文件被签出后必须要等

待它被提交确认后才能进行更改。
方式2效率更高一些，但是多人同时进行修改操作时有可能会引发冲突。

SVN常用的命令：
   checkout, authentication, update, add, delete, commit, rename, import, export...

关于命令的一点说明：
commit: 不要把垃圾文件提到到服务器，垃圾文件包括中间文件，与具体机器环境相关的文件，可以由其它文件生成的文件等。
rename: Windows系统对于文件名不区别大小写而SVN区分，所以在改名时请注意。SVN的rename功能实际是delete再add。
import: 用于将本地文件导入SVN，导入内容不包含当前目录。
export: 用于导出SVN目录结构，导出的结果不会带有隐藏的.svn目录。
resloved: 用于解决完冲突之后确认新的文件。当两个人先后修改了同一部分的内容后，再提交就会产生conflicts，小模型的冲突可以手动使用differ工具修改再resloved确认，大规模的冲突就需要放弃修改结果重新编辑了。

Log Message：
每次提交的时候都应该写上log，来说明所做的改动，可自己定义某种log格式。

属性：
SVN中可给目录增加property，比较重要的属性是external，这用来表示一个外部引用，使用方法为：FloderName   URL，结果是在目录下创建一个以URL地址为内容的文件夹。external link始终保持最新，只要修改原始内容，所有的引用都会更新。这很适合来管理系统的公共部分的内容。

tag：一个非常有用的命令，用来创建一个系统的快照，把所有的文件锁定到某一个指定的版本号。需要注意的是在tagging的时候external link仍然会保持到最新的版本，所以在tagging之前需要手动指定一个external的版本号，在URL前面加上-r xxx来指定是哪个版本的external。并在tagging完成之后还原这些external，否则它们就不始终保持到最新的版本。

Sunshine Alike 2010-07-30 14:24 发表评论

Windows动态链接库DLL[实践]

Sunshine Alike — Wed, 07 Jul 2010 16:24:00 GMT

一直对动态链接库这个东西很陌生，今天刚好调试别人写的一个DLL项目，顺便就来研究一下下。
动态链接库的原理，好处那些就先不说了，直接来看怎么使用。
首先写一个动态链接库，其中 __declspec(dllexport)是用于MS编译器的一个关键字，用来将DLL中的内容导出而不需要.def文件了。
下面的cpp里就函数的定义了，DllMain函数跟普通的win32 console的main函数很像。
使用cl /c DLLImplement.cpp
link /dll DLLImplement.obj
就可以得到一个DLLImplement.dll顺便也会导出一个DLLImplement.lib这个跟静态链接库很像的东西，实际上它的作用只是导出那些方法和变量的名字。

1 extern "C"
2 {
3     __declspec(dllexport) void Set(int i);
4     __declspec(dllexport) int Get();
5     __declspec(dllexport) void SayHello();
6
7     int value;
8 }

1 #include <iostream>
2 #include <objbase.h>
3 #include "DLLHeader.h"
4
5
6 void Set(int i)
7 {
8     value = i;
9 }
10 int Get()
11 {
12     return value;
13 }
14 void SayHello()
15 {
16     std::cout<<"Hello, I'm DLL, value is "<<value<<std::endl;
17 }
18
19
20 BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
21 {
22     HANDLE g_hModule;
23
24     switch(dwReason)
25     {
26     case DLL_PROCESS_ATTACH:
27        std::cout<<"DLL is attached!"<<std::endl;
28        g_hModule = (HINSTANCE)hModule;
29        break;
30
31     case DLL_PROCESS_DETACH:
32        std::cout<<"DLL is detached!"<<std::endl;
33        g_hModule=NULL;
34        break;
35     }
36
37     return TRUE;
38 }
39

使用DLL的方法，有3种：使用def文件/使用LoadLibrary和GetProcAddress方法/使用导出的lib配合头文件。
第一种太麻烦这里不介绍，只说明一下后两种的使用方法。

1 #include <iostream>
2 #include <windows.h>
3
4 typedef void (*SET)(int);
5 typedef int (*GET)(void);
6 typedef void (*SAYHELLO)(void);
7
8 int main(int argc, char **argv)
9 {
10     SET pSet = 0;
11     GET pGet = 0;
12     SAYHELLO pSayHello = 0;
13
14     HINSTANCE hinst=::LoadLibrary("DLLImplement.dll");
15     if (0 == hinst)
16     {
17         std::cout<<"load dll failed!"<<std::endl;
18         return -1;
19     }
20
21     pSet = (SET)GetProcAddress(hinst, "Set");
22     pGet = (GET)GetProcAddress(hinst, "Get");
23     pSayHello = (SAYHELLO)GetProcAddress(hinst, "SayHello");
24
25     if (0 == pSet || 0 == pGet || 0 == pSayHello)
26     {
27         std::cout<<"get function failed!"<<std::endl;
28         return -1;
29     }
30
31     //ready to call the function
32     (*pSet)(10);
33     int i = (*pGet)();
34     std::cout<<"Get value from dll, value is "<<i<<std::endl;
35     (*pSayHello)();
36
37     return 0;
38 }

这种调用方法属于显示调用，使用的时候需要知道DLL文件的路径，还有DLL里面的方法的名字，还是有点不太方便。更多的时候，都是使用最后一种隐式调用的方法，即配合头文件和导出的lib，需要在进行链接的时候加入DLLImplement.lib即可，方法如下：

1 #include <iostream>
2 #include "DLLHeader.h"
3
4 using namespace std;
5
6
7 int main (int argc, char **argv)
8 {
9     Set(100);
10     cout<<"Set value in DLL"<<endl;
11     int i = Get();
12     cout<<"Get value in DLL, value is "<<i<<endl;
13
14     SayHello();
15     return 0;
16 }

到这里对DLL有了一个大概的感性认识，具体的理论性的知识，等有机会慢慢再写出来。

抱怨一句，最近有点懒了，想要写的日志都没写。
找实习也麻烦，写代码肩膀脖子酸痛。
IT民工的命咋就这么苦哩。

Sunshine Alike 2010-07-08 00:24 发表评论

Python编程练习一：StaffSalaryApp

Sunshine Alike — Fri, 23 Apr 2010 08:30:00 GMT

学习了一些Python的基础知识之后，就开始来实践吧。
上手非常简单，有过一定编程经验的人大约可以在几个小时之内掌握基本的Python编程方法。
正好在学习设计模式课程，会有几次课程作业，就直接拿过来权当Python的一次编程练习了
第一次任务简介：
实现一个管理雇员薪水的工具，可以打印出员工的薪水信息。
雇员分为普通和经理，各自有不同的薪水计算方法。

Ok，Let's go！
首先复习一下Python里的面向对象相关知识，定义一个雇员的基类EmployeeBase
并且在__init__方法里定义了三个成员name, base_salary和overtime_days
需要注意的就是所有的类成员方法在声明的时候都需要有一个默认的参数self，这个相当于this指针的东西必须要写上，而且访问类成员或者方法也都要加上这个前缀，不然会出错。

1 class EmployeeBase():
2     """Base class of all staffs"""
3     def __init__(self, name = "", basesalary = 0, overtime = 0):
4         self.name = name
5         self.base_salary = basesalary
6         self.overtime_days = overtime
7     def GetName(self):
8         return self.name

接下来就是普通雇员类Employee，继承的语法：Employee(EmployeeBase)
以及类的__doc__，养成写注释的习惯。
Line 6：
__init__并不是构造函数，并且Python里也没有构造函数这个概念。所以要手动的调用基类的__init__方法
GetSalary中计算薪水，普通雇员的加班工资是双倍计算的。

1 class Employee(EmployeeBase):
2     """Common employee class derived from EmployeeBase.
3     A employee can has overtime salary, every overtime work's salary will be doubled
4     """
5     def __init__(self, name="", basesalary=0, overtime=0):
6         EmployeeBase.__init__(self,name,basesalary,overtime)
7     def GetStaffType(self):
8         return "Employee"
9     def GetSalary(self):
10         return self.base_salary + self.base_salary/30*2*self.overtime_days
11     def GetSalaryInfo(self):
12         return self.name + " : " + self.GetStaffType()+ " : " + str(self.GetSalary())

到这里，雇员类已经完成，下面就是——单元测试。一般我以前写程序都很少写单元测试的，因为很费时，要写很多测试的代码。
但是这里我想特别尝试一下，以展现Python里的各种特性和工具。
新版本的Python里有一个专门用于测试的unittest模块，导入就可以使用了，下面新建一个Testsalary.py进行单元测试。
首先unittest模块里有一个测试用例的基类TestCase，我们只要在TestCase的派生类里定义自己的测试用例方法就可以使用了，这些测试用命方法甚至都不需要自己调用，只要方法名字以test开头，TestCase就会自动的调用它们。
在下面的测试代码中，我定义了testNoneEmployee等几个测试方法，主要是使用了TestCase里的assertEqual方法。

"""Unit test for salary.py"""
import unittest
from salary importEmployee

class TestEmployee(unittest.TestCase):
    """Unit test for clas Employee"""
    def testNoneEmployee(self):
        e = Employee()
        self.assertEqual("",e.GetName())
        self.assertEqual(0,e.GetSalary())
        self.assertEqual("Employee",e.GetStaffType())
    def testBaseSalary(self):
        e = Employee("emp", 300)
        self.assertEqual("emp",e.GetName())
        self.assertEqual(300,e.GetSalary())
        self.assertEqual("Employee",e.GetStaffType())
    def testNoOvertime(self):
        e = Employee("emp", 300, 0)
        self.assertEqual(300,e.GetSalary())
        self.assertEqual("emp : Employee : 300", e.GetSalaryInfo())
    def testOvertime1(self):
        e = Employee("emp", 300, 1)
        self.assertEqual(320,e.GetSalary())
        self.assertEqual("emp : Employee : 320", e.GetSalaryInfo())
    def testOvertime2(self):
        e = Employee("emp", 300, 5)
        self.assertEqual(400,e.GetSalary())
        self.assertEqual("emp : Employee : 400", e.GetSalaryInfo())

if __name__ == "__main__":
    unittest.main()

运行之，出现结果：

----------------------------------------------------------------------
Ran 5 tests in 0.007s

OK

全部通过，太没意思了，想着要加点什么好呢。下面我对构造Employee的时候加上参数的检查，不允许不正确的参数输入，例如名字太长，工资和加班天数为负数等。我希望在试图用这些不正确的参数进行创建Employee对象的时候出现异常。
在测试代码中加入另两个方法，使用了TestCase里的另一个方法assertRaises，这个方法可以检测被测对象是否按抛出了预期的异常。这个方法接受一个异常类型，和一个会产生这种异常的“对象”，通常是一个函数，以及它们的参数

    def testInvalidName(self):
        self.assertRaises(InvalidName, Employee, "name too long")
    def testInvalidInput1(self):
        self.assertRaises(InvalidInput, Employee, "emp", -300)
    def testInvalidInput2(self):
        self.assertRaises(InvalidInput, Employee, "emp", 300, -5)

两种异常类的名字分别叫InvalidName和InvalidInput，这下测试通不过了。下面就需要修改Employee类，首先提一下Python里的异常处理，使用try...except...处理异常，raise抛出异常，finally可以用来做一些善后处理工作。
下面先要定义上面用到的这两种异常，InvalidName和InvalidInput，这里简单的继承一下Python里的Exception类就可以了，然后修改Employee的__init__方法，进行参数的查检，修正后如下：

#new type of Expceptions
class InvalidName(Exception):pass
class InvalidInput(Exception):pass

#－－－－－－－－－－－－－－－－－－－－－－

    def __init__(self, name="", basesalary=0, overtime=0):
        #raise exceptions if input is invalidate
        if len(name) > 8:
            raise InvalidName, "Error: Name too long!"
        if basesalary < 0 or basesalary > 300000:
            raise InvalidInput, "Error: Base salary should between 0~300000!"
        #use int(overtime) != overtime to check if the input is int
        if overtime < 0 or overtime  > 31 or int(overtime) != overtime:
            raise InvalidInput, "Error: Overtime should between 0~31!"
        EmployeeBase.__init__(self,name,basesalary,overtime)

ps：异常类型后面的文字是为了给，异常处理提供信息用的。

OK，第一步顺利完成，下面就是经理类。经理的工资由加班工资和绩效组成，加班工资只跟经理的等级有关，它与绩效工资都是一个固定值，基本上没有什么难度。

Sunshine Alike 2010-04-23 16:30 发表评论

一点软件设计的体会：设计模式和UML

Sunshine Alike — Sat, 10 Apr 2010 05:19:00 GMT

这学期开始认真学习设计模式这门课，老师课上说了一句话：在设计模式出现以前，软件开发是门艺术，只有那些有天赋的程序员才能写有优雅的代码；设计模式被人们总结出来之后，软件开发就成了一门技术了，有着固定的模式可以参考，没有天赋的程序员也可以写出很好的代码。
先不管这句话的正确与否，但是有一点是确定的，软件的开发过程中，设计是非常重要的。有一个好的设计能够将软件开发失败的机率降到最低。
设计模式不应该被视为软件开发的说明书，照着那一条一条的模式套用并不一定能写出来好的程序，正确的态度应该是把它们作为软件设计的经验和建议来看。
最近看了下那本《敏捷软件开发：原则、模式与实践》，感觉确实是本好书，可以看出来作者对软件开发的功力非常丰富。我发现作者在说明软件开发过程的时候大量使用了UML，以前我都认识这些东西很虚，很麻烦。现在看这本书的时候却有点了不同的体会，哈哈，看来是我以前层次太低了。UML实在是一个好东西，清晰明了，用来描述复杂的系统的时候真有种拨云见日的感觉。

下面简单写一下UML的基本知识：
1.识别参与者
2.抽取用例
用例中有两点需要说明一下：扩展(extension)/包含(include)
扩展：它们之间互不引用，仅仅插入到被扩展用例中
包含：包含用例会引用被包含的用例
基本用例完成之后，可以根据参与者将其分类组织起来，形成系统的边界图来汇总显示。

3.领域模式(domain)
这是一种类似于UML类图,但是它们之间有很大的差别，它并不会对应于编码中的类(class)。
4.类之间的关系
关联：以一条线连接两个类表示，表示它们之间相互包含。更常见的是一种带箭头单向关联关系。
聚合：以一个白色菱形箭头表示类之间的“整体/局部”关系，同样聚合关系的一个变体“组合”，以一个黑色菱形箭头表示，这也是一种“整体/局部”关系，但是“部分”不能脱离“整体”而存在，“整体”也必须负责管理“部分”的生存期。
举例：家庭和人是聚合关系，而电脑与CPU是组合关系

Sunshine Alike 2010-04-10 13:19 发表评论

一个小故事：老师在毕业典礼上的讲话

Sunshine Alike — Sat, 10 Apr 2010 04:23:00 GMT

   其一，“世界上第一高峰是哪座山?”大家哄堂大笑：“珠穆朗玛峰!”老师追问：“第二高峰呢?”同学们面面相觑，无人应声。老师在黑板上写：“屈居第二与默默无闻毫无区别。 ”

其二，“有人要烧壶开水，等生好火发现柴不够，他该怎么办?”有的说赶快去找，有的说去借、去买。老师说：“为什么不把壶里的水倒掉一些?”大家一听，表示佩服。

其三，“古代有一人，想学立身的本领。经过反复比较，决心去学屠龙之技。他拜名师，日夜苦练，终有所成。他会怎么样呢?“同学们兴致勃勃，说他能成为英雄、明星，受世人崇拜。老师摇头：“这个人一定会潦倒一生，因为世上根本就没有龙。”

   你们应该要学会“如何做人、做事、做学问”：
   做人要力求出色，勇争第一，这样别人才能发现你、记住你；
   做事要敢于创新，方法灵活，千万不可墨守成规；
   做学问要学以致用，要懂得将知识转化为效益，闭门造车没有路。

Sunshine Alike 2010-04-10 12:23 发表评论

有一些想法，慢慢开始整理一下

Sunshine Alike — Mon, 05 Apr 2010 13:27:00 GMT

Dare比赛的事情暂时告下一段落，虽然当时热情挺高，但是事过一半才发现原来其它人并不是都这么想的。自从上了大学之后越发的感觉到再也很难跟别人想到一块去了，单纯的年代已经远去喽。近来听说一个发小都要结婚了，啧啧，我这八字还没一撇呢。。。

以前一直觉得父母跟自己和不来，但是现在突然发现，是自己太固执了。以前总觉得他们的处事方式不顺眼，现在自己经历过一些事情之后，才知道原来前人们留下的经验不可能都是吃饱了撑的没事干拍拍脑门凭空想出来的，今后还需多向他们请教为人处事的经验。

再就是近来感觉常忘事，本来自制力就不够。一疏忽就浪费不少时间，以致于先前相好的计划常常完成不了。不应该啊不应该，以后应该多写计划，写下来！把任务分类别、管理好自己的时间。离毕业不远了，把握当下！！

Sunshine Alike 2010-04-05 21:27 发表评论

Command和ActiveObjcet模式

Sunshine Alike — Fri, 02 Apr 2010 09:04:00 GMT

Command模式，一个传说中非常简单的模式，但是其应用还真不简单。
通过接口将某些方法封装起来以达到解除系统逻辑互联关系的耦合的效果，并且实现了Command接口的类对象可以在系统中自由的重新组合，参数传递也非常方便，为系统带来灵活性的提升。
其应用范围包括数据库的事务操作、设备控制、多线程核心以及GUI的do/undo操作。

ActiveObject模式是使用Command模式的应用之一，这是实现多线程控制的一种技术。

下面是一个简单的实例：
1. 一个Command接口，定义了Execute方法。
2. 两个类SleepingCommand和PrinterCommand实现了Command中的Execute方法。
在PrinterCommand中调用Execute时打印一个字符并创建一个新的PrinterCommand在指定的延时后执行。
SleepingCommand表示一个睡眠中的Command，他在执行时只是简单的将自己放到链表末尾直到等待的事件（设定的延时到来）发生它才会将自己唤醒等待下一步执行。
3. 一个StopCommand类，实现了用于终止Command链循环的Execute方法。
4. 一个ActiveObjectManager对象，维护了一个Command对象链表，用户可以像Manager中AddCommand对象或者便利链表并依次调用Command对象的Execute方法执行任务。

Sunshine Alike 2010-04-02 17:04 发表评论

Python！Python！！

Sunshine Alike — Tue, 30 Mar 2010 14:34:00 GMT

突然一时兴起找了个Python的Tutorial看了一下下，哈哈，感觉非常好，很小巧很讨喜的语言，比较有特点。第一印象是很简单，语法简洁而又功能强大，准备要尝试学一下。

下面贴一点学习的笔记：

一、基本知识
Python同时即是脚本解释器，又是一个可以运行命令行的shell。在shell里可以计算任务Python表达式，甚至包括变量赋值，这些变量在shell打开时一直有效，关闭时丢失数据。

函数声明，以def开始，函数名，参数，冒号后面跟函数体。需要注意的是Python里的格式都以缩进的形式来表达，没有类C/C++中的大括号。另外函数不需要指定返回值类型，实际上，如果函数有return语句，它将返回指定类型值，否则返回None（Python的空值）。

Python即是动态语言，它不需要显示数据类型声明，赋值的同时即完成变量声明。又是强类型语言，一个变量一旦获得一个数据类型，它实际上就一直是这个类型的了。

Python里的“对象”概念，这里的“对象”不同于以前接触到的OO里的对象，Python里的对象定义更为广泛。一个程序块，一个变量，甚至一个字符串都可以是一个对象。其具体含义还需要根据上下文来判断。

三种重要的内置数据类型：Dictionary，List，Tuple：
Dictionary对应于C++中的map和Java中的hashtable，也就是一个键值对集合。
List对应于C++中的vector和java中的ArrayList，一个可以动态自动扩展的数组。
Tuple是一个不可变的list，一旦创建就不能以方式改变它，但是好在Python提供了在Tuple和List之间相互转换的函数。
需要注意的是List和Tuple是可以存储混合类型的数组的，并且都可以通过索引取值（包括负的索引值，其表示从逆序取值）

For语句：
Python里的for语句不同于C/C++中的for，更类似于C#中的foreach循环或者是Java中的for (int i : IntArray)。Python的for语句需要配合一个range函数使用，它有三个参数，并返回一个Tupe数组用于表示索引，三个参数是start,stop,step，例如range（0，5，1）则返回[0，1，2，3，4]；range（5，0，－1）则返回[5，4，3，2，1]。

字符串格式化：
与C中类似%d，%f，%s等等，通过字符串的join函数可以方便的将list的内容合并成字符串。

and/or：
and和or负责执行布尔逻辑运算，但是它们不返回布尔值而是返回它们实际进行比较的值之一。非空的对象被认为是真，空对象则被认为是假。and运算会返回第一个假值，而or运算返回第一个真值，其它部分都不会被计算到。

lambda函数：
一种快速定义的单行最小函数，只有一行，类似于内联的感觉。例如一个例子：
ld = lambda i : i*i
ld(10) # == 100
理论上lambda函数可以有多个参数（包括可选参数）并且隐含的返回单个表达式的值。

两种导入（import）方法：

Python中有两种导入模块的方法： import xx / from xx import yy

它们的差别在于，from xx import yy这种方式，yy被直接导入到了局部命名空间中（类似于C++中的using），在以后使用yy的时候不再需要（不能）加上模块名称限定。也就是说，如果使用import方式导入模块，在使用它里面的一个变量的时候，你不得不每次都加上前缀xx.来表示使用的是位于xx模块中的变量，而使用from导入时，则不需要加入前缀。

异常处理：
Python中使用try...except来处理异常，使用raise来引发异常。并且，一个except后面可以跟一个else块来表示没有捕获预期异常时的行为。一个try块后面也可以跟一个finally块来保证一些代码总是被执行到，比如打开文件后的关闭操作。

注释：
Python里使用#来作为单选注释开始符，使用三个冒号作为多行注释"""content"""，
需要注意的是后一种形式的注意经常被用来作为函数或者类的"说明",写在这里的内容可以被其使用者当作参考手册来使用，Ptyhon里所有对象都具有一个内置的__doc__属性，通过它可以查看各个对象的说明，应该养成写__doc__的习惯。一般其格式为首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。

引号：
Python里有单引号，双引号和三引号。其中单引号和双引号都可以用来表示字符串，例如
print 'string' == "string" 将会打印出True
设置这两种字符串引号的目的是为了简化引号的表示，例如如果字符串里含有引号本身就需要使用\来进行标识，例如：'let\'s go!'，“he said:\"get out!\"”。
如果字符串里含有大量这种情况会显得非常麻烦，可以交替使用单引号和双引号来避免这种情况。上面的例子可以改为："let's go!"，'he said:"get out!"'。
而三引号就是用来表示一个多行字符串。它们经常被用来定义文档字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。建议从一开始就遵守这个惯例。

二、面向对象

类的定义：
以class开头，pass表示结束（实际上没有特定的u），例如一个简单的类定义为
class Person:
    pass
如果要表示继承关系只需要将基类用括号回到类名后面即可，Python支持多重继续，每个基类中间以逗号隔开。
class Student（Person）：
pass
这里的pass语句仅表示占位之用，没有特别的含义。

类成员定义：
__init__方法，这个函数的功能很类似于Java或者C++中的构造函数，但是仍存在一点细小的差别，__init__函数的第一个参数一定是self，类似于C++中的this指针。
__init__方法的定义并不是必须的，但是一旦你定义了它，就必须显示的调用父类的__init__方法。
需要注意的是，所有的类成员方法都必须定义一个参数（self），但它的名字不是一定的，其作用类似于C++中的this指针。
__del__方法，类似于析构函数，在使用del语句的时候被调用。

重载：
Python的类没有任何形式的函数重载，即一个方法名称只能对应一个方法，如果子类中定义的与基类中同名的方法，则会将其覆盖掉。

成员属性：
Python中有两种类型的成员方法：普通类方法和专用类方法。
成员也有两种访问级别：公开的和私有的。
其中公开和私有成员的表示没有特别的关键字，只是体现的方法名称上，私有成员的名称以两个短小的下划线作为开始例如：
class A:
__privatevalue
publicvalue
def __set(self, v):
    __privatevalue = v
def get(self):
    return publicvalue
pass
并且，一个成员是属于类的还是属于对象的，是通过定义这个变量的域来确定的，定义在类体内的变量由所有成员共享，通过self定义的变量则为成员变量。
此外，类的成员方法还分为：普通类方法和专用类方法。普通方法的定义与普通函数定义类似，它是公开的，在类外部可以被调用。而类的专用方法，没有特殊的关键字来表示，只是在方法的名称前后各加上两个短的下划线，例如def __getitem__。这种专用方法是由用户显式调用的，它有点操作符重载的意思在里面，但是功能比操作符重载要强大一些。Python允许我们自己定义需要的类专用方法，例如任何定义了__cmp__方法的类就可以用＝＝进行比较，任何定义了__len__方法的类就可以用len(instance)进行取长度。

三、标准库
1.文件操作
Python中有一个内置函数open可以用来打开文件
file = open("pictures/dog.bmp","rb")
open函数可以接受三个参数：文件名，模式和缓冲区参数，但是只有每一个参数是必须的，文件会默认以文本方式打开。
文件的读取和C中类似，tell()返回当前文件位置，seek来移动文件操作的位置。具体的函数使用方法可以使用print seek.__doc__来查看

处理I/O错误：
try:
file = open(filename, "rb", 0)
try:
    file.seek(-128,2)
    data = file.read(128)
    file.seek(0,2)
    file.write("succeeded")
    finally:
      file.close()
expect IOError:
    pass

Python提供了一个os.path模块来进行目录操作，具体使用方法就不详细写出来了，用过几次就记住了。

2.序列化
标准库里有两个模块都提供这个功能，pickle和cPickle，用于将对象存储到文件中而后再读取出来。
但是后者是使用C语言写的，速度要比前面的快很多，但是功能都是一样的。
使用也很简便主要就是使用dump和load函数

－－－－－－－－－－－－－－－－－－待续－－－－－－－－－－－－－－－－

Sunshine Alike 2010-03-30 22:34 发表评论

Life is Hard!

Sunshine Alike — Sun, 21 Mar 2010 07:17:00 GMT

不到一个月，才开了两个项目，就乱成一锅粥了，真郁闷。
一个好的团队真是太重要了，而在学校里，这个太不靠谱了。
总有人来混事，总有人来闹矛盾，总有人有这样那样的想法，总有人不理解你，完全无奈了。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
做游戏真是辛苦，需要学的东西太多了，找不到方向
现在真是有点理解那句话：“当你把一个兴趣，变成了职业之后，悲剧就开始了！”
为了当年心里的兴趣，转了方向来搞游戏，我想现在是遇到瓶颈了，动力不足。。。。

Sunshine Alike 2010-03-21 15:17 发表评论

Linux Note

Sunshine Alike — Sun, 14 Mar 2010 13:06:00 GMT

最近才开始接触linux系统（Ubuntu 9.10），有些东西容易忘记，备忘之，待续。

1.g++编译问题

//main.cpp
#include <iostream>
using namespace std;

//headers
void show();

int main()
{
    cout<<"library test function show(): ";
    show();
    return 0;
}

//libtest.cpp
#include <iostream>
using namespace std;

void show()
{
cout<<"hello library test!"<<endl;
}

静态库：
首先编译libtest.cpp生成中间文件 libtest.o
g++ -c libtest.cpp
然后将其打包成静态库 staticlib.a
ar -rc staticlib.a libtest.o
最后使用静态库与main.cpp进行编译得到执行文件staticlib
g++ -o staticlib main.cpp staticlib.a
运行./staticlib 成功！！

动态库：
首先同样需要编译生成中间文件libteset.o，但一般加上-fPIC选项。
其意思是位置独立代码，指示编译程序生成的代码要适合共享库的内容这样的代码能够根据载入内存的位置计算内部地址
g++ -c -fPIC libtest.cpp
然后打包生成动态库dynamiclib.so
g++ -shared libtest.o -o dynamiclib.so
最后生成可执行文件dynamiclib
g++ -o dynamic main.cpp dynamiclib.so
运行./dynamiclib 结果出错了，提示找不到动态库。
原因是linux下动态库不像windows里那样会自动寻找当前目录下的dll，这需要把编译出来的动态库放到系统的 /usr/lib 或 /lib下才能运行程序。
或者还可以在编译的时候就指定路径也可以，例如在最后一步的时候：
g++ -o dynamic main.cpp ./dynamiclib.so
再次运行./dynamiclib 成功！！

Sunshine Alike 2010-03-14 21:06 发表评论