博客园_刘其超晒太阳的鱼

单链表实现(c版)

2011-07-27T14:50:00Z

----写前：这是一个做为练习记录，别无它用。不足之处还请指正！

这次练习线性链表环境为ubuntu10.10+vim+gcc，分三个文件，一个是nodetype.h，node.h,listnode.c。

源码如下：

nodetype.h源码：

#ifndef _NODETYPE_H_
#define _NODETYPE_H_

#define OK 1;
#define ERROR 0;

typedef int ElemType;
typedef int Status;
#endif

node.h源码：

#ifndef _NODE_H_
#define _NODE_H_

#include "nodetype.h"

typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode;

Status DisplayList(LNode *head);
LNode * CreateList(LNode *head,int n);
LNode* InsertElement(LNode *head,int position,ElemType data);
LNode* GetElement(LNode *head,int position);
#endif

listnode.h源码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "node.h"

LNode * CreateList(LNode *head,int n)
{
        LNode *p,*p1;
        p1 = head = ( LNode * )malloc( sizeof(LNode) );
        if(NULL == p1)
        {
                printf("Apply memory failed \n");
                return head;
        }
        p1->next = NULL;
        printf("Please input the list root data:");
        scanf("%d",&p1->data);
        return head;
}

Status DisplayList(LNode *head)
{
        printf("-----------------------------\n");
        LNode *temp;
        temp = head;
        while(temp !=NULL)
        {
                printf("Address:0x%x\tData:%d\tNext:0x%d \n",(unsigned int)temp,temp->data,(unsigned int)temp->next);
                temp = temp->next;
        }
        printf("-----------------------------\n");
}

LNode* InsertElement(LNode *head,int position,ElemType data)
{
        if(NULL != head)
        {
LNode *node;
                node=(LNode *)malloc(sizeof(LNode));
                LNode *p1;
                p1=head;
                if(position <= 1)
                {
                        node->data=data;
                        node->next=p1;
                        head=node;
                }
                else
                {
                        int i=0;
                        for(i=1;i<position-1;i++)
                        {
                                p1=p1->next;
                        }
                        if(NULL != node)
                        {
                                node->data=data;
                                node->next=p1->next;
                                p1->next=node;
                        }
                }
        }
        return head;
}
LNode *GetElement(LNode *head,int position)
{
        LNode *node;
        if(NULL != head)
        {
LNode *p1;
                p1=head;
                while((position--)>1 && NULL !=p1->next)
                {
                        p1=p1->next;
                }
                if(NULL != p1)
                        node=p1;
        }
        return node;
}
void main()
{
        LNode *node;
        node=NULL;
        node=CreateList(node,3);
        if (node == NULL)
        {
                printf("Create List Failure!\n");
        }
        DisplayList(node);
        int pos,val=1;
        while(val>0)
        {
                printf("Please input the data position and value(as 1,2 end by value<1) which you want to insert:");
                scanf("%d,%d",&pos,&val);
                node=InsertElement(node,pos,val);
                DisplayList(node);
        }
        LNode *elem;
        pos=1;
        while(pos)
        {
                printf("Please input the position no. which element you want to find(end by position<1):");
                scanf("%d",&pos);
                elem=GetElement(node,pos);
printf("Element at %d  data: %d\n",pos,elem->data);
        }
        free(node);
}

以下为部分截图：

源码图

测试图

注：未完待续(只写了创建链表、插入、获取、打印四个函数)

本文链接

动态链接库解析

2011-07-04T09:21:00Z

题记：

此文主要对windows和Linux下对动态链接库调用的一些简单说明，比如多个应用调用同一个动态链接库(后面简称DLL，希望不要误解)时，DLL是一个应用启动一个(可能描述不太恰当，但意思希望能理解)还是调用的同一个内在地址？DLL中的静态区是一个一份还是共用静态区？函数是一个一份还是共用？这些都是我们在编写DLL与调用时需要思考的地方。

正文：

首先，我们先谈谈windows下用调用动态链接库。我用的IDE是开源跨平台的codeblocks，然后创建一个动态链接库项目。我在里面就写了两个简单的

DLL_EXPORT函数。我在里面定义了一些静态变量和普通变量。用来测试静态变量和普通变量等是如何存储的（是共享还是各自有一个copy），这里说下最终结果吧，我会在后面把代码附上，大家可以下载。结果是，静态是各自copy一份，供各自调用，而函数等则理共享的。所以他们的函数的入口地址都是完全一样，因为是共享的。

下面是动态链接库中main.h的代码

#ifndef __MAIN_H__
#define __MAIN_H__

#include <windows.h>

/*  To use this exported function of dll, include this header
*  in your project.
*/

#ifdef BUILD_DLL
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT __declspec(dllimport)
#endif

#ifdef __cplusplus
extern "C"
{
#endif
int DLL_EXPORT Max(int a,int b);
int DLL_EXPORT StaticFuc();
#ifdef __cplusplus
}
#endif
#endif // __MAIN_H__

下面是main.cpp

#include "main.h"

// a sample exported function

int DLL_EXPORT Max(int a,int b)
{
    return a>b?a:b;
}

int DLL_EXPORT  StaticFuc()
{
    static int d=20;
    return d++;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // attach to process
            // return FALSE to fail DLL load
            break;

        case DLL_PROCESS_DETACH:
            // detach from process
            break;

        case DLL_THREAD_ATTACH:
            // attach to thread
            break;

        case DLL_THREAD_DETACH:
            // detach from thread
            break;
    }
    return TRUE; // succesful

}

下面是InvokeDLL中的main.cpp文件，用来调用动态链接库，并验证

#include <windows.h>
#include <stdio.h>

typedef int(*pMax)(int a,int b);
typedef int(*pStaFuc)();

int main()
{
    HINSTANCE hDLL;
    hDLL = LoadLibrary("D:\\cplus\\DLLDemo\\bin\\Debug\\DLLDemo.dll");
    pMax Max;
    {
        Max=(pMax)GetProcAddress(hDLL,"Max");
        int a = Max(0,1);
        printf("function address: 0x%X \n",(unsigned int)&Max);
        printf("%d \n",a);
    }
    pStaFuc StaFuc;
    {
        StaFuc=(pStaFuc)GetProcAddress(hDLL,"StaticFuc");
        int retVal = StaFuc();
        printf("function address: 0x%X \n",(unsigned int)&StaFuc);
        printf("%d \n",retVal);
    }
    FreeLibrary(hDLL);
    return 0;

}

下面是截图：

下面是同时开启三个InvokeDLL2.exe和一个InvokeDLL.exe

从这个运行结果是可以看出调用动态链接库的原理。

Linux,

linux下的动态链接库在/lib目录下，以.so(shared object共享对象)作后缀的文件，这就是linux系统应用的动态链接库。而静态函数库是以.a作后缀。

首先，我建立一个名为testso.c文件，在C文件中我定义了两上函数，一个是Strlen用来获取字符串长度，另外一个是Display用来打印一行记录，代码如下：

1 /***********************************
2 Filename : testso.c
3 Description :
4 Author   : Rockay.lau
5 Date     : 2011-07-05
6 URL      :Http://rockay.cnblogs.com
7 ************************************/
8
9 #include <stdio.h>
10 #include <assert.h>
11
12 int Strlen(char *pStr)
13 {
14         unsigned long len;
15         assert(NULL != pStr);
16         len=0;
17         while(*pStr++)
18         {
19                 len++;
20         }
21         return len;
22 }
23
24 void Display()
25 {
26         printf("Hello Rockay!\n");
27 }

代码编写完后，我们用命令生成动态链接库文件，命令如下：

gcc -fpic -shared -o libtest.so testso.c

运行效果如下图：

这里我们再写一个invoke.c的文件，这里主要用来调用前面的动态链接库，代码如下：

1 /***********************************
2 Filename : invoke.c
3 Description :
4 Author   : Rockay.lau
5 Date     : 2011-07-05
6 URL      :Http://rockay.cnblogs.com
7 ************************************/
8
9 #include <stdio.h>
10 #include <dlfcn.h>
11
12 #define sofile "./libtest.so"
13
14 int main()
15 {
16         void (*pPrintFun)(void);
17         int  (*pStrFun)(char *);
18
19         char str[]={"rockay lau"};
20
21         void *pdlHandle;
22         char *pszErr;
23
24         pdlHandle=dlopen(sofile,RTLD_LAZY);
25         if(!pdlHandle)
26         {
27                 printf("Load standard object failed! \n");
28         }
29
30         pszErr=dlerror();
31         if(pszErr!=NULL)
32         {
33                 printf("Error: %s \n",pszErr);
34         }
35
36         pPrintFun=dlsym(pdlHandle,"Display");
37         pszErr=dlerror();
38         if(pszErr==NULL)
39         {
40                 pPrintFun();
41         }
42
43         pStrFun=dlsym(pdlHandle,"Strlen");
44         pszErr=dlerror();
45         if(pszErr==NULL)
46         {
47                 int len=pStrFun(str);
48                 printf("string length: %d \n",len);
49         }
50
51         return 0;
52 }

然后输入如下命令：

gcc -ldl -o invoke invoke.c

运行效果如下图：

这样，一个简单的linux下的动态链接库调用完成，关于静态变量和函数地址调用是否与windows下相同，则留给大家去验证一下。这里就不再详细描述！

最后，如果你写的动态链接库使用平台硬件环境比较差时，那么动态链接库尽量少用静态的东西。那样可以节省很多很多的空间。道听途说No***某某手机公司就是这样规定的。

本文链接

字节对齐详解(转)

2011-06-26T15:48:00Z

注：转自 http://blogold.chinaunix.net/u1/45525/showart_436243.html

一.什么是字节对齐,为什么要对齐?

现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。

二.字节对齐对程序的影响:

先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义：
struct A
{
    int a;
    char b;
    short c;
};
struct B
{
    char b;
    int a;
    short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)
short:2(有符号无符号同)
int:4(有符号无符号同)
long:4(有符号无符号同)
float:4    double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

三.编译器是按照什么样的原则进行对齐的?

先让我们看四个重要的基本概念：
1.数据类型自身的对齐值：
对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。
有了这些值，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析：
分析例子B；
struct B
{
    char b;
    int a;
    short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4，所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0009到0x0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C：
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
第一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1= 0;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放
在0x0006、0x0007中，符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C 只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?

1.在VC IDE中，可以这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。
2.在编码时，可以这样动态修改：#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,我们在编程中如何考虑?

    如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做法是显式的插入reserved成员：
         struct A{
           char a;
           char reserved[3];//使用空间换时间
           int b;
}

reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.

六.字节对齐可能带来的隐患:

代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。例如：
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐.

七.如何查找与字节对齐方面的问题:

如果出现对齐或者赋值问题首先查看
1. 编译器的big little端设置
2. 看这种体系本身是否支持非对齐访问
3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

ARM下的对齐处理
from DUI0067D_ADS1_2_CompLib

3.13 type qulifiers

有部分摘自ARM编译器文档对齐部分

对齐的使用:
1.__align(num)
   这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
   就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
   这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
   对齐,但是不能让4字节的对象2字节对齐。
   __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。

2.__packed
__packed是进行一字节对齐
1.不能对packed的对象进行对齐
2.所有对象的读写访问都进行非对齐访问
3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
4.__packed对局部整形变量无影响
5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
义为packed。
     __packed int* p; //__packed int 则没有意义
6.对齐或非对齐读写访问带来问题
__packed struct STRUCT_TEST
{
char a;
int b;
char c;
} ;    //定义如下结构此时b的起始地址一定是不对齐的
         //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
//将下面变量定义成全局静态不在栈上
static char* p;
static struct STRUCT_TEST a;
void Main()
{
__packed int* q; //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

p = (char*)&a;
q = (int*)(p+1);

*q = 0x87654321;
/*
得到赋值的汇编指令很清楚
ldr      r5,0x20001590 ; = #0x12345678
[0xe1a00005]   mov      r0,r5
[0xeb0000b0]   bl       __rt_uwrite4 //在此处调用一个写4byte的操作函数

[0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
[0xe1a02420]   mov      r2,r0,lsr #8
[0xe5c12001]   strb     r2,[r1,#1]
[0xe1a02820]   mov      r2,r0,lsr #16
[0xe5c12002]   strb     r2,[r1,#2]
[0xe1a02c20]   mov      r2,r0,lsr #24
[0xe5c12003]   strb     r2,[r1,#3]
[0xe1a0f00e]   mov      pc,r14
*/

/*
如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
[0xe59f2018] ldr r2,0x20001594 ; = #0x87654321
[0xe5812000] str r2,[r1,#0]
*/

//这样可以很清楚的看到非对齐访问是如何产生错误的
//以及如何消除非对齐访问带来问题
//也可以看到非对齐访问和对齐访问的指令差异导致效率问题
}

本文链接

数据结构第二章之线性表C实现

2011-06-26T15:25:00Z

这是我毕业两年后重新学习数据结构的第二章学习笔记，这里就不多说线性表的结构，其中参考了网上一些关于头文件的声明，直接上代码，不知道的可以G一下：

1.一些数据类型和宏定义

#ifndef _TYPE_H_
#define _TYPE_H_
#define TRUE    1
#define FALSE   0
#define OK      1
#define ERROR   0
#define INFEASIBLE -1
#define OVERFLOW   -2
typedef int Status;
typedef char ElemType;
#endif

2.主要是宏文件和函数定义

#ifndef _LINE_H_
#define _LINE_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "type.h"

#define INIT_SIZE 20
#define INCREMENT 10

typedef struct LineArray
{
        ElemType *elem;
        int length;
        int listsize;
}Sqlist;

Status InitList(Sqlist &);
Status DestroyList(Sqlist &);
Status InsertList(Sqlist &L,int pos,ElemType e);
Status CopyList(Sqlist *L,char *s);
Status DeleteList(Sqlist *L,int pos);
Status FindElem(Sqlist *L,char );
Status UnionList(Sqlist **L,Sqlist *R);
#endif

3.具体的实现

#include "line.h"

Status InitList(Sqlist **L)
{
        (*L)->elem=(ElemType *)malloc(INIT_SIZE*sizeof(ElemType));
        if((*L)->elem==NULL)
                exit(OVERFLOW);
        (*L)->length=0;
        (*L)->listsize=INIT_SIZE;
         memset((*L)->elem,0,(*L)->listsize);
        printf("Initial line list success! \n");
        return OK;
}

Status DestroyList(Sqlist **L)
{
        if(((*L)->elem))
       {
                free((*L)->elem);
                (*L)->elem=NULL;
                printf("Destroy line list success! \n");
        }
}

Status CopyList(Sqlist *L,char *str)
{
        int len=strlen(str);
        if(len > L->listsize-1)
        {
                L->elem = (ElemType *) realloc(L->elem,(L->listsize + len + INCREMENT)* sizeof(ElemType) );
                L->listsize += INCREMENT +len;
                memset(L->elem,0,L->listsize);
        }
        strncpy(L->elem,str,len);
        L->length=len+1;
        return OK;
}

Status InsertList(Sqlist **L,int pos,ElemType e)
{
        //step1:check if the pos is bigger than line's length
        if(pos < 1 || pos > ((*L)->length+1) )
                return ERROR;
        //step2:check the elements size
        if((*L)->length>=(*L)->listsize)
        {
                //add space
                (*L)->elem=(ElemType*) realloc ( (*L)->elem , ( (*L)->listsize+INCREMENT) * sizeof(ElemType) );
                (*L)->listsize+=INCREMENT;
        }
        if((*L)->elem==NULL)
                return OVERFLOW;
        ElemType temp=(*L)->elem[pos];
        int len=(*L)->length;
        for(;len>=pos-1;len--)
        {
                (*L)->elem[len+1]=(*L)->elem[len];
        }
        (*L)->elem[pos-1]=e;
        ++((*L)->length);
        return OK;
}
void printlist(Sqlist *L,char *msg)
{
        if(L->elem==NULL)
                printf("%s :line list is null\n",msg);
        else
        {
                printf("============%s start=============\n",msg);
                printf("\tData:%s\n",L->elem);
                printf("\tLength:%d\n",L->length);
               printf("\tSize:%d\n",L->listsize);
                printf("============%s   end=============\n",msg);
        }
}

Status DeleteList(Sqlist *L,int pos)
{
        //check the pos
        if( pos < 1 || pos > L->length )
                return ERROR;
        int len=L->length;
        for(;pos<=len;pos++)
        {
                L->elem[pos-1]=L->elem[pos];
        }
        --(L->length);
}
Status FindElem(Sqlist *L,char c)
{
        if(L->elem==NULL)
                return ERROR;
        char *p=L->elem;
        while(*p)
        {
                if(*p==c)
                {
                        return OK;
                }
                p++;
        }
        return FALSE;
}

Status UnionList(Sqlist **L,Sqlist *R)
{
        if( (*L)->elem == NULL || R->elem == NULL )
                return ERROR;
        int lenr=R->length;
        if( lenr > ( ((*L)->listsize) - ((*L)->length) ))
        {
                (*L)->elem = (ElemType *)realloc( (*L)->elem , ((*L)->listsize + R->listsize + INCREMENT) * sizeof(ElemType) );
        }
        int i;
        for( i=0 ; i<lenr ; i++)
        {
                if( FALSE == FindElem(*L,R->elem[i]) )
                {
                        InsertList(L , (*L)->length , R->elem[i] );
                }
        }

        return OK;
}
void main()
{
        Sqlist *pArray,Array;
        Sqlist *pSrc,Src;
        pArray=&Array;
        pSrc=&Src;
        InitList(&pArray);
        InitList(&pSrc);
        CopyList(pArray,"rockay");
        CopyList(pSrc,"liuataolaceflc2423ko");
        printlist(pArray,"Copy");
        InsertList(&pArray,2,'1');
        printlist(pArray,"Insert");
        DeleteList(pArray,3);
        printlist(pArray,"Delete 3");
        FindElem(pArray,'a');
        UnionList(&pArray,pSrc);
        printlist(pArray,"Union ");
        DestroyList(&pArray);
        exit(0);
}

4.最后，linux下用vim编译后运行结果

rockay@ubuntu:~/cws/algorithm$ gcc line.c
rockay@ubuntu:~/cws/algorithm$ ./a.out
Initial line list success!
Initial line list success!
============Copy start=============
    Data:rockay
    Length:7
    Size:20
============Copy   end=============
============Insert start=============
    Data:r1ockay
    Length:8
    Size:20
============Insert   end=============
============Delete 3 start=============
    Data:r1ckay
    Length:7
    Size:20
============Delete 3   end=============
============Union  start=============
    Data:r1ckayliutoef243
    Length:18
    Size:20
============Union    end=============
Destroy line list success!
rockay@ubuntu:~/cws/algorithm$

好了，一个简单的线性表结构的相关操作完成了，由于代码的函数和变量命名不规范，还请大家不要学习这种习惯，函数也还未考虑进算法的优化等情况。

本文链接

操作系统原理-任务调度

2011-06-11T10:42:00Z

--内核的主要职责就是任务调度

任务调度有三种：时间片调度、轮转调度、优先级调度(抢占式)。

本文链接

关于责任与梦想

2011-05-23T16:02:00Z

----今天看了这段时间我挺挂念的一个人的博客，我发现其实我以前真的不懂她，现在很成熟，希望她幸福。最近还在时常梦见她。lee.

感情：到今年(2011)7月1号，我们就毕业两年了，这两年中，有起有落，有欢笑也有悲伤。一直在走向梦想的路。毕业这两年，我真正从心里面就爱过一个女孩，但后来我们分开了，或许并没开始，也是因为我个人的原因，所以现在的我不敢恋爱，现在有个我高中时喜欢过的女孩想与我一起，但我现在的心真的有点麻木了，感觉已经对女人找不到谈情的感觉了，我一直对自己说，先把事业做好，以后找个人把婚结了，要求是她能把家和亲人照顾好就行了，但这真那么简单吗？现在我真的不想再恋爱了。或许是我真的感觉累了，不愿意付出了吧。等缘份吧。我可能会选择不与你耍，对不起。我真的找不到在一起的冲动。我怕。

工作：从毕业后，换了三个工作，现在这个工作也是我去年换的。但我现在从心里有点烦，一是公司团队有问题，二是个人的问题吧。本开年打算离开现在公司，但责任放在肩头，我希望是在公司好的时候离开，而不是在公司低谷的时候离开，这样我可以昂着头离开，我可以感觉自己不是抛弃公司。责任让我等到现在近6月份了，我不知道还能不能再等下去，中途有几个朋友都介绍了不错的工作，但我都一一回拒了，我还是希望把我的责任继续完成下去，即使最后我会没有选择的余地，但我问心无愧，或许有人会笑我傻，这社会应该讲现实，但我还是希望自己是有人情味的活着，谁不明白“人不为己，天诛地灭”的道理呢，先做好人，再去做好事。我还是尊重内心的选择，虽然我内心是矛盾的。但我坚持到6月底，也先把部门经理这一职位辞掉，让有能力者居之，祝我的朋友和公司都好好的。人生就一次，没有重头再来的机会，珍惜吧，努力吧，去爱吧，用心吧。

本文链接

关于ldd3的学习Hello world

2011-04-27T17:15:00Z

备注：

最近工作挺忙，这两天晚上我还是抽时间出来弄了第一个Hello world实例，因为公司以后产品有可能往linux下跑，所以提前学习，做技术储备。

在Linux下写第一个设备驱动程序让我受尽折磨，因为学习linux系统还要追朔到2006年左右，那时培训学校组织统一实战培训，所以学了天空一角的linux，这直到现在2011年才又来用linux，命令已经完全忘记，非常之痛苦，先网上找到命令手册，然后再VI下编写第一个Hello world，由于对命令都不熟悉，更不用说写一个设备驱动程序，这两天晚上都被此折磨。今天晚上在坚持不懈的努力下，终于攻破了第一关，最关键的一点，是linux下区分大小写，以前是记得区分大小写，但这两天没在意，让我吃尽苦头。

本文链接

WPF内存与控件焦点

2011-04-22T17:02:00Z

题记：

最近工作上很忙，也全身心的投入工作中，晚上还要抽时间学习单片机和Linux设备驱动编写，所以很久没更新博客了。

本文链接

Oracle同义词学习(转)

2010-12-30T09:19:00Z

同义词：从字面上理解就是别名的意思，和Oracle数据库中的视图功能类似。就是一种映射关系。可以远程操作数据库。

1.创建同义词语句：

　　create public synonym table_name for user.table_name;

其中第一个user_table和第二个user_table可以不一样。

此外如果要创建一个远程的数据库上的某张表的同义词，需要先创建一个Database Link(数据库连接)来扩展访问，然后在使用如下语句创建数据库同义词：create synonym table_name for table_name@DB_Link;

当然，你可能需要在user用户中给当前用户(user2)授权： grant select/delete/update on user2

　　2.删除同义词：

　　drop public synonym table_name;

3.查看所有同义词：

　　select * from dba_synonyms

同义词拥有如下好处：节省大量的数据库空间，对不同用户的操作同一张表没有多少差别;扩展的数据库的使用范围，能够在不同的数据库用户之间实现无缝交互;同义词可以创建在不同一个数据库服务器上，通过网络实现连接。

本文链接

RS232与RS485口区别(转)

2010-12-01T15:36:00Z

RS232，RS485的区别

1.RS-232-C是美国电子工业协会EIA（Electronic Industry Association）制定的一种串行物理接口标准。RS是英文“推荐标准”的缩写，232为标识号，C表示修改次数。RS-232-C总线标准设有25条信号线，包括一个主通道和一个辅助通道，在多数情况下主要使用主通道，对于一般双工通信，仅需几条信号线就可实现，如一条发送线、一条接收线及一条地线。RS-232-C标准规定的数据传输速率为每秒50、75、 100、150、300、600、1200、2400、4800、9600、19200波特。RS-232-C标准规定，驱动器允许有2500pF的电容负载，通信距离将受此电容限制，例如，采用150pF/m的通信电缆时，最大通信距离为15m；若每米电缆的电容量减小，通信距离可以增加。传输距离短的另一原因是RS-232属单端信号传送，存在共地噪声和不能抑制共模干扰等问题，因此一般用于20m以内的通信。

2.RS-485总线,在要求通信距离为几十米到上千米时，广泛采用RS-485 串行总线标准。RS-485采用平衡发送和差分接收，因此具有抑制共模干扰的能力。加上总线收发器具有高灵敏度，能检测低至200mV的电压，故传输信号能在千米以外得到恢复。 RS-485采用半双工工作方式，任何时候只能有一点处于发送状态，因此，发送电路须由使能信号加以控制。RS-485用于多点互连时非常方便，可以省掉许多信号线。应用RS-485 可以联网构成分布式系统，其允许最多并联32台驱动器和32台接收器。

以往，PC与智能设备通讯多借助RS232、RS485、以太网等方式，主要取决于设备的接口规范。但RS232、RS485只能代表通讯的物理介质层和链路层，如果要实现数据的双向访问，就必须自己编写通讯应用程序，但这种程序多数都不能符合ISO/OSI的规范，只能实现较单一的功能，适用于单一设备类型，程序不具备通用性。在RS232或RS485设备联成的设备网中，如果设备数量超过2台，就必须使用RS485做通讯介质，RS485网的设备间要想互通信息只有通过“主（Master）”设备中转才能实现，这个主设备通常是PC，而这种设备网中只允许存在一个主设备，其余全部是从（Slave）设备。而现场总线技术是以ISO/OSI模型为基础的，具有完整的软件支持系统，能够解决总线控制、冲突检测、链路维护等问题。

本文链接

博客园_刘其超 晒太阳的鱼

单链表实现(c版)

动态链接库解析

字节对齐详解(转)

数据结构第二章之线性表C实现

操作系统原理-任务调度

关于责任与梦想

关于ldd3的学习Hello world

WPF内存与控件焦点

Oracle同义词学习(转)

RS232与RS485口区别(转)

博客园_刘其超晒太阳的鱼