void BaoCun(int count)
{
    FILE *fp;
    fp = fopen("qizi", "wb");
    fwrite(&Zuobiao[count - 1], sizeof(Zuobiao), 1, fp);
    fclose(fp);
}
想用这个函数把结构体数组里的数读进文件里，为啥文件里是空的呢?
struct zuobiao
{
    int x[400];
    int y[400];
} Zuobiao[400];结构体是这样的

1. 你看看 fwrite 的返回值，写入了几个字节
2. 路径要搞对。你查看的 qizi 文件，是不是你写入的 qizi 文件。
3. 你是怎么获知“文件里是空”的？在文件上点右键，选择“属性”，看看“文件大小”。

从代码看，你要保存的是 一个结构体，应该不是结构 体数组， fwrite 第二个参数应该传 sizeof(struct zuobiao)

#include <stdio.h>
#include <string.h>
struct zuobiao
{
    int x[400];
    int y[400];
} Zuobiao[400] = {0};


void BaoCun(int count)
{
    FILE *fp;
    fp = fopen("qizi", "w");
    fwrite(&Zuobiao[count-1], sizeof(struct zuobiao), 1, fp);
    fclose(fp);
}



int main() {
    Zuobiao[399].x[10] = 1;
    BaoCun(400);
    struct zuobiao z;
    FILE *fp;
    fp = fopen("qizi", "r");
    fread(&z, sizeof(struct zuobiao), 1, fp);
    printf("%d\n", z.x[10]);
    fclose(fp);
    return 0;
}

返回值是1，文件大小是0，这是怎么回事

你确认一下我提到的第二点有没有搞错，也就是你写入的文件是不是你查看的文件。
比如，先将你看到的 qizi 文件删除掉，然后再运行一下程序，看看是不是重新生成了。

另外，你的代码很奇怪，你应该拿 3 楼 fulltimelink 的代码测试一下。

你的代码是将 &Zuobiao[count-1] 之后的400个 struct zuobiao 写入文件，但你的 Zuobiao 一共也就是400个元素。也就是仅当你的count等于1时，代码逻辑才是正确的。

文件删除了，会重新生成，下面是我的代码，我写了注释，我也不知道咋整，可以帮我看一下吗，谢谢您
我是想用循环逐个读入坐标，之后再用另外一个函数读出来

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

//●○

int qipan[20][20] = {0};
void menu();
void InitQiPan();            //初始化棋盘
void XiaQi(int count);     //获取坐标数据,并判断该坐标是否已经有子
//void BaoCun(int count);      //将坐标数据保存到文件中
void PrintfQiPan(int count);

//打印游戏菜单
void menu()
{
    int op;//此变量为菜单选项
    //打印菜单
    printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
    printf("~           *简易五子棋游戏菜单*              ~\n");
    printf("~           *    0.进入游戏    *              ~\n");
    printf("~           *    1.退出游戏    *              ~\n");
    printf("~           *    2.帮助        *              ~\n");
    printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
    scanf("%d", &op);//输入选项
    switch(op)
    {
    case 1://输入1时结束
    {
        exit(0);
    }
    case 2://输入2时，系统给出“帮助”
    {
        printf("帮助：\n五子棋是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。\n"
               "本游戏中，黑子先落，白子在其后，根据行、列坐标，下在棋盘交叉点处。\n先形成五子连线者获胜！\n");
        break;
    }
    case 0:
    {
        return ;//输入0时，返回主函数，进行后续操作
    }
    default:
    {
        printf("选项错误！请重新作出你的选择。。。。\n");  //当输入的数字没有时，系统会发出提示，再选一次
        getchar();//若玩家输入字符时，可用getchar()将其读走
        menu();//重新返回菜单
    }
    }
}

struct zuobiao
{
    int x[400];
    int y[400];
} Zuobiao[400];

//初始化一个棋盘，让界面只打印出一个棋盘
void InitQiPan()
{
    int i, j;//i,j均为坐标
    for(i = 1; i <= 20; i++)
    {
        printf("%d ", i % 10);  //打印列坐标
    }
    printf("\n");
    for(i = 1; i <= 20; i++)
    {
        for(j = 1; j <= 20; j++)
        {
            printf("·"); //打印棋盘
        }
        printf(" %d", i);//打印棋盘行坐标
        printf("\n");
    }
}

void XiaQi(int count)
{
    int i, j, k;
again:
    ;
    printf("请输入棋子坐标，如2,3...：");
    scanf("%d,%d", &i, &j);   //输入坐标
    while(i < 1 || i > 20 || j < 1|| j > 20)
    {
        printf("坐标格式错误！！！请重新输入棋子坐标，如2,3...：");
        fflush(stdin);  //清除缓冲区
        scanf("%d,%d", &i, &j);//重新输入坐标
    }
    for(k = 1; k <= count; k++)
    {
        if(Zuobiao[k].x[k] == i && Zuobiao[k].y[k] == j)
        {
            printf("此坐标上已有棋子！！请重新输入：");
            goto again;
        }
    }
    /*
    Zuobiao[count].x[count] = i;
    Zuobiao[count].y[count] = j;
    if(count % 2 == 1)
    {
        qipan[i][j] = 1;
    }
    if(count % 2 == 0)
    {
        qipan[i][j] = 2;
    }
    */
}

void BaoCun(int count)//用循环保存坐标
{
    FILE *fp;
    fp = fopen("C:\\CB\\game1\\qizi", "wb");
    fwrite(&Zuobiao[count - 1], sizeof(struct zuobiao), 1, fp);
    //fclose(fp);
}

void PrintfQiPan(int count)
{
    int i, j, k;
    for(i = 1; i < 21; i++)
    {
        printf("%d ", i);
    }
    printf("\n");
    for(i = 1; i <= 20; i++)
    {
        for(j = 1; j <= 20; j++)
        {
            for(k = 1; k <= count; k++)//这个循环是把count个棋子打印在棋盘上
            {
                if(Zuobiao[k].x[k] == i && Zuobiao[k].y[k] == j)
                {
                    if( qipan[i][j] == 1)
                    {
                        printf("●");
                        break;
                    }
                    else if( qipan[i][j] == 2)
                    {
                        printf("○");
                        break;
                    }
                }
            }
            if(k <= count)//中途找到棋子返回
            {
                continue;
            }
            else//没找到对应（i,j）上有棋子
            {
                printf("·");//在该位置上打印一个焦点
            }
        }
        printf(" %d\n", i);//打印行坐标
    }
}

int main()
{
    int m;
    menu();
    InitQiPan();
    for(m = 1; m < 400; m++)
    {
        XiaQi(m);
        BaoCun(m);
        PrintfQiPan(m);
    }

    return 0;
}

你为什么要把 fclose(fp); 删掉？

void BaoCun(int count)//用循环保存坐标
{
    FILE *fp;
    fp = fopen("C:\\CB\\game1\\qizi", "a+");
    fwrite(&Zuobiao[count - 1], sizeof(struct zuobiao), 1, fp);
    fclose(fp);
}


我改成了这个，文件大小也在不断增加，但是打开文件里面是小框框
下面我加了一个读文件的函数，打印不出来棋子，
为什么读不到数据呢


void PrintfQiPan(int count)
{
    int i, j, k;
    FILE *fp;
    fp = fopen("C:\\CB\\game1\\qizi","rb");
    for(i = 1; i < 21; i++)
    {
        printf("%d ", i);
    }
    printf("\n");
    for(i = 1; i <= 20; i++)
    {
        for(j = 1; j <= 20; j++)
        {
            for(k = 1; k <= count; k++)//这个循环是把count个棋子打印在棋盘上
            {
                fread(&Zuobiao[k], sizeof(struct zuobiao), 1, fp);
                if(Zuobiao[k].x[k] == i && Zuobiao[k].y[k] == j)
                {
                    if( qipan[i][j] == 1)
                    {
                        printf("●");
                        break;
                    }
                    else if( qipan[i][j] == 2)
                    {
                        printf("○");
                        break;
                    }
                }
            }
            if(k <= count)//中途找到棋子返回
            {
                continue;
            }
            else//没找到对应（i,j）上有棋子
            {
                printf("·");//在该位置上打印一个焦点
            }
        }
        printf(" %d\n", i);//打印行坐标
    }
}

[此贴子已经被作者于2020-6-17 14:08编辑过]

文件里是乱码你可以把黑白棋子用a，b替换，再看看文件内容

操作系统：Win10
编译器：VC++2019 或 MinGW-w64 8.1.0
全程鼠标操作

#include <windows.h>
#include <string_view>
#include <sstream>
#include <vector>

class Console
{
public:
    Console()
    {
        hinput_ = GetStdHandle( STD_INPUT_HANDLE );
        houtput_ = GetStdHandle( STD_OUTPUT_HANDLE );
        GetConsoleMode( hinput_, &mode_ );
        COORD curpos = GetCursorPosition();
        lefttop_ = COORD{ 0, SHORT(curpos.Y+(curpos.X>0)) };
    }
    ~Console()
    {
        SetConsoleMode( hinput_, mode_ );
        ShowCursor( true );
    }

    void ShowCursor( bool bShow )
    {
        CONSOLE_CURSOR_INFO cursor;
        GetConsoleCursorInfo( houtput_, &cursor );
        cursor.bVisible = bShow;
        SetConsoleCursorInfo( houtput_, &cursor );
    }

    void EnableQuickEditMode( bool bEnabled )
    {
        DWORD mode;
        GetConsoleMode( hinput_, &mode );
        if( bEnabled && (mode&ENABLE_QUICK_EDIT_MODE)==0 )
            SetConsoleMode( hinput_, mode|ENABLE_QUICK_EDIT_MODE );
        else if( !bEnabled && (mode&ENABLE_QUICK_EDIT_MODE)!=0 )
            SetConsoleMode( hinput_, mode&~ENABLE_QUICK_EDIT_MODE );
    }
    void EnableMouseInput( bool bEnabled )
    {
        DWORD mode;
        GetConsoleMode( hinput_, &mode );
        if( bEnabled && (mode&ENABLE_MOUSE_INPUT)==0 )
            SetConsoleMode( hinput_, mode|ENABLE_MOUSE_INPUT );
        else if( !bEnabled && (mode&ENABLE_MOUSE_INPUT)!=0 )
            SetConsoleMode( hinput_, mode&~ENABLE_MOUSE_INPUT );
    }
    bool GetInputEvent( INPUT_RECORD& record )
    {
        DWORD n;
        if( ReadConsoleInput(hinput_,&record,1,&n) && n==1 )
        {
            if( record.EventType == MOUSE_EVENT )
            {
                record.Event.MouseEvent.dwMousePosition.X -= lefttop_.X;
                record.Event.MouseEvent.dwMousePosition.Y -= lefttop_.Y;
            }
            return true;
        }
        return false;
    }

    COORD GetCursorPosition( void ) const
    {
        CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
        GetConsoleScreenBufferInfo( houtput_, &ScreenBufferInfo );
        return ScreenBufferInfo.dwCursorPosition;
    }
    void SetCursorPosition( SHORT rx, SHORT ry )
    {
        SetConsoleCursorPosition( houtput_, COORD{SHORT(lefttop_.X+rx),SHORT(lefttop_.Y+ry)} );
    }

    template<typename T> void Output( SHORT rx, SHORT ry, const T& t, WORD wAttribute=FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED )
    {
        std::ostringstream os;
        os << t;
        Output( rx, ry, std::string_view(os.str()), wAttribute );
    }
    void Output( SHORT rx, SHORT ry, const std::string_view& sv, WORD wAttribute=FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED )
    {
        COORD coord = {SHORT(lefttop_.X+rx),SHORT(lefttop_.Y+ry)};
        DWORD n;
        WriteConsoleOutputCharacterA( houtput_, sv.data(), sv.size(), coord, &n );
        FillConsoleOutputAttribute( houtput_, wAttribute, n, coord, &n );
    }
    void Output( SHORT rx, SHORT ry, char ch, WORD wAttribute=FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED )
    {
        Output( rx, ry, std::string_view{&ch,1}, wAttribute );
    }

private:
    HANDLE hinput_;
    HANDLE houtput_;
    DWORD mode_;
    COORD lefttop_;
};

class Chess
{
public:
    Chess( SHORT row, SHORT col ) : row(row), col(col), buf(row*col,EMPTY)
    {
        csl.ShowCursor( false );
        csl.EnableMouseInput( true );
        csl.EnableQuickEditMode( false );
        csl.SetCursorPosition(0,row+1+2);
    }
    ~Chess()
    {
    }
    void PrintBoard()
    {
        for( SHORT c=0; c!=col; ++c )
            csl.Output( 2*c+0, 0, c+1 );
        for( SHORT r=0; r!=row; ++r )
            csl.Output( 2*col+0, r+1, r+1 );
        for( SHORT i=0; i!=row*col; ++i )
            PrintSingle( i%col, i/col );
        csl.Output( 0, row+2, "X", FOREGROUND_RED|FOREGROUND_INTENSITY );
        csl.Output( 1, row+2, " --- quit" );
    }
    void PrintSingle( SHORT x, SHORT y )
    {
        const char* p;
        switch( buf[y*col+x] )
        {
        default:     p="·"; break;
        case USER_A: p="●"; break;
        case USER_B: p="○"; break;
        }
        csl.Output( x*2, y+1, p );
    }
    void Run()
    {
        PrintBoard();
        State user = USER_B;
        for( INPUT_RECORD record; csl.GetInputEvent(record); )
        {
            if( record.EventType ==  MOUSE_EVENT )
            {
                if( record.Event.MouseEvent.dwEventFlags==0 && record.Event.MouseEvent.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED ) // 鼠标不移动 且 左键下压
                {
                    COORD pos = record.Event.MouseEvent.dwMousePosition;
                    if( pos.X>=0 && pos.X<2*col && pos.Y>=1 && pos.Y<1+row )
                    {
                        SHORT r = pos.Y-1;
                        SHORT c = pos.X/2;
                        if( buf[r*col+c] == EMPTY )
                        {
                            user = user==USER_A ? USER_B : USER_A;
                            buf[r*col+c] = user;
                            PrintSingle( c, r );
                        }
                    }
                    else if( pos.X==0 && pos.Y==row+2 ) // quit
                        break;
                }
            }
        }
    }

private:
    Console csl;
    SHORT row, col;
    enum State { EMPTY=0, USER_A, USER_B };
    std::vector<State> buf;
};

int main( void )
{
    Chess a( 20, 20 );
    a.Run();

    return 0;
}