pr=pr->next;这一句删了

您看 ，我这样可以吗？我前面再把main（）里面修改为struct clerk* head=(struct clerk*)malloc(struct clerk_);head=readToLink(head);print(head);因为我的目的是传到readToLink（struct clerk* head_)以后，我把head_赋值给p，那么head_和p就同时指向一段内存（我用来标记为头指针，待会返回head_,就是返回一个单链表）然后移动pr通过循环，一次次给pr申请空间建立新链表节点，并且通过p=p->next把新建节点连到上一节点，直到文件读完。动态数据结构这一方面我一直很头疼，在学校上学期学了一学期，最后的动态数据结构草草收尾，自己弄了大半天，用的不是很熟悉，不发帖真不知道落后啊。。。谢谢了

我在main（）里面第一句改成：struct clerk* head=(struct clerk*)malloc(struct clerk);

程序的结构，要注意合理分解函数，你这个设计有点捣糨糊，把自己搅浑了，思路混乱，当然写不好。

链表犹如串珠，通过指针把前后的珠子串连在一起。因此，首先得有珠子，有珠子自然有地址，再把前珠和后珠用指针挂起，就成了，这是链表的基本原理。那么，从文件中读数构造链表怎么办呢？其实很简单，文件读数就只做读数，不要参与构造链表，这个与它读取文件数据的职责无关，它所要负责的，就是从文件中读入一个struct clerk型数据，把这个数据交给构造链表的模块，后者把这个数据与前珠串连起来，如此循环，直至构造完毕。

正常的程序结构，是做一个链表的创建函数，它返回一个链表的入口地址。这个函数用一个struct clerk head建立链头，然后用malloc()申请一块struct clerk内存，借用一个中介变量struct clerk temp，从文件中读入一个struct clerk数据交给temp，再把temp通过memcpy()复制给前面申请的动态内存（这个过程中可以视你操作指针的熟练程度减少复制赋值环节，但若不熟练，直接用数据实体操作即可，又不是几百M一个结点，能耗多少时间，内存复制赋值再慢，也比外设IO快得多，这里的速度瓶颈在文件读写上），复制成功后，把两个珠子串起来，然后再读……再串……直至文件读完。最后，把链头地址&head返回给上一层，这样，两个基本函数就成型了。这样分拆程序的函数，你的思路就清晰了，写起来不容易错。不要学人玩技巧，以为省掉几个变量声明和定义很高明，没用的，清晰性才是第一位的，先保无错。先正确，后快——让正确的程序快起来，比让快的程序正确起来，容易得多多多。

[ 本帖最后由 TonyDeng 于 2012-4-4 13:15 编辑 ]

办法是人想出来的。

刚刚是急着弄程序 ，看，今天弄一天了，但是我还是没有把它成功弄出来，这是我刚刚最后修改的程序，我觉得逻辑也对，就是行不通，刚刚的帖子无意冒犯，抱歉
#include<stdio.h>
#include<stdlib.h>
struct clerk* readToLink(struct clerk* head_);
void print(struct clerk* head);
struct clerk
{
    char clerkNum[10];
    char name[20];
    int  age;
    char position[10];
    char salaries[10];
    struct clerk* next;
};
 main()
 {
     struct clerk info;
     struct clerk* head;
     //("%d\n",sizeof(*head));
     head=readToLink(&info);
     print(head);
 }
struct clerk* readToLink(struct clerk* head_)
{
    FILE* a;
    struct clerk* p=head_,*pr;
    if((a=fopen("jia.txt","a+"))==0)
        printf("fail to open the file!\n");
         ;//保存当前节点的指针//head_是头指针

    do
    {
        pr=(struct clerk*)malloc(sizeof(struct clerk));
        if(pr==NULL)
        {
        printf("No enough memory to allocate!\n");
            exit(0);
        }
        fscanf(a,"%10d%5s%2d%10s%6f",pr->clerkNum,pr->name,pr->age,pr->position,pr->salaries);//按数据块读入文件//按数据块读取
        //printf("%d\n",sizeof(*p));//测试p
        p->next=pr;
        p=pr;
    }while(!feof(a));
    pr->next=NULL;
    fclose(a);
    return head_;
}
void print(struct clerk* head)
{
    struct clerk* pr=head->next;
    while(pr->next!=NULL)
    {
        //printf("%d\n",pr->age);
        printf("%10d %5s %2d %10s %6f\n",head->clerkNum,head->name,head->age,head->position,head->salaries);
        pr=pr->next;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <conio.h>

struct clerk
{
    char   clerkNum[10];
    char   name[20];
    int    age;
    char   position[10];
    double salaries;
    struct clerk* next;
};

const char file_name[] = "e:\\Projects\\test\\test_Clerk\\clerk.dat";

void init_data(const char* file_name);
void print_data(const clerk* data);
bool save_data(const char* file_name, const clerk* data, const int count);
clerk* load_data(const char* file_name);
void release(clerk* data);

void main(void)
{
    // 初始化测试数据
    // init_data(file_name);

    // 从文件中读入链表数据并输出
    clerk* data = load_data(file_name);
    clerk* p = data;
    while (p != NULL)
    {
        print_data(p);
        p = p->next;
    }
    _getch();
    release(data);
    data = NULL;
}

void init_data(const char* file_name)
{
    const clerk data[] =
    {
        { "001", "lusvan",     20, "beijing",  3000.0, NULL },
        { "002", "hellovfp",   30, "shanghai", 5000.0, NULL },
        { "003", "embed_xuel", 28, "shenyang", 5000.0, NULL }
    };
    save_data(file_name, data, _countof(data));
}

void print_data(const clerk* item)
{
    printf_s("     Num: %s\n", item->clerkNum);
    printf_s("    Name: %s\n", item->name);
    printf_s("     Age: %d\n", item->age);
    printf_s("Position: %s\n", item->position);
    printf_s("Salaries: %.2f\n", item->salaries);
    printf_s("\n");
}

bool save_data(const char* file_name, const clerk* data, const int count)
{
    bool success = false;

    FILE* file;
    if (fopen_s(&file, file_name, "wb") == 0)
    {
        success = true;
        for (int i = 0; i < count; ++i)
        {
            if (fwrite(&(data[i]), sizeof(clerk), 1, file) != 1)
            {
                success = false;
                break;
            }
        }
        fclose(file);
    }
    else
    {
        printf_s("Data file open error!\n");
    }

    return success;
}

clerk* load_data(const char* file_name)
{
    clerk* head = NULL;                                         // 链头
    FILE* file;
    if (fopen_s(&file, file_name, "rb") == 0)
    {
        clerk item;                                             // 中介数据项
        clerk* p = NULL;                                        // 当前结点指针
        clerk* previous = NULL;                                 // 前项结点指针
        bool first = true;
        while (fread(&item, sizeof(clerk), 1, file) == 1)       // 从文件中读入一笔记录
        {
            if ((p = (clerk *)malloc(sizeof(clerk))) != NULL)   // 申请结点内存空间
            {
                memcpy(p, &item, sizeof(clerk));                // 把读入的数据项复制给当前结点
                p->next = NULL;                                 // 初始化下项指针
                if (previous != NULL)
                {
                    previous->next = p;                         // 如果有前项，则令前项的下结点指针指向当前结点
                }
                previous = p;                                   // 令当前结点成为下一项的前项
                if (first)
                {
                    head = p;                                   // 如果这是第一笔记录，则它是链表头，用于返回作为链表的入口
                    first = false;
                }
            }
            else
            {
                break;
            }
        }
        fclose(file);
    }
    return head;                                                // 返回链表头
}

void release(clerk* data)
{
    clerk* next = NULL;
    while (data != NULL)
    {
        next = data->next;
        free(data);
        data = next;
    }
}