学习记录，从０开始

小墨hacker

　　今年９月中旬接触Ｃ语言，计算机专业学生。
　　说来也是缘分。高考分数很理想，却因为报考的大学太热门没进到学校的王牌专业“建筑规划”。
　　九月前几乎没接触过编程（高二的时候玩网游用过按键精灵．．．）。自认为为０基础的自己会跟不上学校的学习节奏，就百度了入门经验，晚上捧着网友推荐的《Ｃ Primer Plus》看（那时学校还没发教材）。看是看书实在太枯燥了进度几乎为0，直到后来机缘巧合之下发现了小甲鱼的C语言教学视屏，又通过视屏了解到论坛。
      看视屏学习进度飞快，现在已经能做出贪吃蛇了，哈哈。到了程序设计课都想翘掉，觉得学校课太慢了。（学校也有视屏，但是学校的MOOC视屏简直就是惨不忍睹...和有声教材读物没啥区别）
      我会把我每天的进度放在这，同时还有问题和笔记等。
      ps.不知道会不会放错板块。板块中没发现长期的记录贴，这不算水贴吧？楼下补上11.10之前的学习记录。

小墨hacker

已经记不得什么了，全是翻文件看看，所以这一部分应该会比较模糊。
9月中旬下旬熟悉输入输出等，练习有单位转换，计算面积，字符串输入输出……
9月下旬接触选择结构。
十月上旬接触简单的子函数及调用（...没按顺序学，我比较贪心，总是翻看后面部分的内容看到不懂就度娘。所以学习的内容基本都是零碎的...到了后来总有东西看不懂，没办法又系统得看了一遍小甲鱼的视屏。希望和我一样刚刚开始学的朋友引以为戒。）
十月中旬看到网友发在贴吧的OX棋思路，也开始边学边做。（其中学了数组、循环等）一个程序边学边做整整做了5天...

1. #include<stdio.h>
   
2. const int KONG=0;
   
3. const int PLAYER1=1;
   
4. const int PLAYER2=2;
   
5. const int *game[3][3]={&KONG,&KONG,&KONG,&KONG,&KONG,&KONG,&KONG,&KONG,&KONG};
   
6. int luoZi_hang;
   
7. int luoZi_lie;
   
8. void QiPan()
   
9. {
   
10.         int hang;
    
11.         int lie;
    
12.         for(hang=1;hang<=3;hang++)
    
13.         {
    
14.                 for(lie=1;lie<=3;lie++)
    
15.                 {
    
16.                         if(*game[hang-1][lie-1]==KONG)
    
17.                         {
    
18.                                 printf("*");
    
19.                         }
    
20.                         else if(*game[hang-1][lie-1]==PLAYER1)
    
21.                         {
    
22.                                 printf("O");
    
23.                         }
    
24.                         else if(*game[hang-1][lie-1]==PLAYER2)
    
25. 
    
26.                         {
    
27.                                 printf("X");
    
28.                         }
    
29.                         if(lie==3)
    
30.                         {
    
31.                                 printf("\n");
    
32.                         }
    
33.                 }
    
34.         }
    
35. }
    
36. void player(const int &per)
    
37. {
    
38.         int luoJi;
    
39.         printf("请玩家%d落子，请输入：\n",per);
    
40.         printf("行：");
    
41.         luoJi=scanf("%d",&luoZi_hang);
    
42.         for(;luoJi!=1||luoZi_hang>3;)
    
43.         {
    
44.                 printf("输入错误，请重新输入：");
    
45.                 scanf("%d",&luoZi_hang);
    
46.         }
    
47.         printf("列：");
    
48.         luoJi=scanf("%d",&luoZi_lie);
    
49.         for(;luoJi!=1||luoZi_lie>3;)
    
50.         {
    
51.                 printf("输入错误，请重新输入：");
    
52.                 scanf("%d",&luoZi_lie);
    
53.         }
    
54.         for(;*game[luoZi_hang-1][luoZi_lie-1]!=KONG;)
    
55.         {
    
56.                 printf("该处以落子请重新输入！\n");
    
57.                 printf("行：");
    
58.                 luoJi=scanf("%d",&luoZi_hang);
    
59.                 for(;luoJi!=1||luoZi_hang>3;)
    
60.                 {
    
61.                         printf("输入错误，请重新输入：");
    
62.                         scanf("%d",&luoZi_hang);
    
63.                 }
    
64.                 printf("列：");
    
65.                 luoJi=scanf("%d",&luoZi_lie);
    
66.                 for(;luoJi!=1||luoZi_lie>3;)
    
67.                 {
    
68.                         printf("输入错误，请重新输入：\n");
    
69.                         scanf("%d",&luoZi_lie);
    
70.                 }
    
71.         }
    
72.         game[luoZi_hang-1][luoZi_lie-1]=&per;
    
73. }
    
74. int win(int p)
    
75. {
    
76.         int num;//相连子个数
    
77.         int a=1;
    
78. 
    
79.         for(a=1,num=1;luoZi_hang-1+a<=2&&*game[luoZi_hang-1+a][luoZi_lie-1]==p;a++)//检测纵向胜利条件
    
80.         {
    
81.                 num++;
    
82. 
    
83.         }
    
84.         for(a=-1;luoZi_hang-1+a>=0&&*game[luoZi_hang-1+a][luoZi_lie-1]==p;a--)
    
85.         {
    
86.                 num++;
    
87.         }
    
88.         if (num==3)
    
89.         {
    
90.                 printf("\n玩家%d胜利-",p);
    
91.                 return 1;
    
92.         }
    
93. 
    
94.         for(num=1,a=1;luoZi_hang-1+a<=2&&*game[luoZi_hang-1][luoZi_lie-1+a]==p;a++)//检测横向胜利条件
    
95.         {
    
96.                 num++;
    
97.         }
    
98.         for(a=-1;luoZi_hang-1+a>=0&&*game[luoZi_hang-1][luoZi_lie-1+a]==p;a--)
    
99.         {
    
100.                 num++;
     
101.         }
     
102.         if (num==3)
     
103.         {
     
104.                 printf("\n玩家%d胜利|",p);
     
105.                 return 1;
     
106.         }
     
107.         for(num=1,a=1;luoZi_hang-1+a<=2&&luoZi_lie-1+a<=2&&*game[luoZi_hang-1+a][luoZi_lie-1+a]==p;a++)//检测\方向胜利条件
     
108.         {
     
109.                 num++;
     
110.         }
     
111.         for(a=-1;luoZi_hang-1+a>=0&&luoZi_lie-1+a>=0&&*game[luoZi_hang-1+a][luoZi_lie-1+a]==p;a--)
     
112.         {
     
113.                 num++;
     
114.         }
     
115.         if (num==3)
     
116.         {
     
117.                 printf("\n玩家%d胜利\",p);
     
118.                 return 1;
     
119.         }
     
120.         for(num=1,a=1;luoZi_hang-1-a>=0&&luoZi_lie-1+a<=2&&*game[luoZi_hang-1-a][luoZi_lie-1+a]==p;a++)//检测/方向胜利条件
     
121.         {
     
122.                 num++;
     
123.         }
     
124.         for(a=-1;luoZi_hang-1-a<=2&&luoZi_lie-1+a>=0&&*game[luoZi_hang-1-a][luoZi_lie-1+a]==p;a--)
     
125.         {
     
126.                 num++;
     
127.         }
     
128.         if (num==3)
     
129.         {
     
130.                 printf("\n玩家%d胜利/",p);
     
131.                 return 1;
     
132.         }
     
133.         else//返回无胜负的返回值
     
134.         {
     
135.                 return 0;
     
136.         }
     
137. }
     
138. int main()
     
139. {
     
140.         int lunCi;
     
141.         int w=0;
     
142.         QiPan();
     
143.         for(lunCi=1;lunCi<=9&&w==0;lunCi++)
     
144.         {
     
145.                 if(lunCi%2==1)
     
146.                 {
     
147.                         player(PLAYER1);
     
148.                         QiPan();
     
149.                         w=win(PLAYER1);
     
150.                 }
     
151.                 if(lunCi%2==0)
     
152.                 {
     
153.                         player(PLAYER2);
     
154.                         QiPan();
     
155.                         w=win(PLAYER2);
     
156.                 }       
     
157.         }
     
158.         if (w==0)
     
159.                 printf("\n平局");
     
160.         return 0;
     
161. }

复制代码

小墨hacker

找不到最开始的程序了，这是十月下旬后来学指针的时候回来改的。
零散的学习进度很快，基本一个月就学到函数、指针这部分。但是弊端也是极其严重，楼主当时连什么是形参实参都不知道（还有全局参数等等，之前依葫芦画瓢没问题，自己一改加入指针部分就疯狂报错。自己还作死加了常量，又弄混了常量指针和指针常量...5555）
后来下旬的时候就开始刷视屏了，把漏洞都补上，感觉这样学特别浪费时间。
当时连DEBUG都不知道，为了检查哪出错了在函数里狂加printf检测各个变量...被自己蠢哭。

小墨hacker

感觉这一段学习过程中除了学习C语言外主要就是三个部分：
1.看懂编译器报错是哪错了，错了什么。（本人英文不好，都是度娘的。错多了自然就记住了）
2.==和=弄混（没有比这更蛋疼的了）后来有学校的师兄提出建议就是（3==a）把变量放右边，现在基本解决。
3.DEBUG！！！很重要但是不难。
大概就是这些，菜鸟厚颜无耻的分享经验全当抛砖引玉，欢迎大神支出错误的地方（包括之前及之后的内容）。
随后就是一边熟悉之前内容，一边做些小程序。
11月初接触图形库，做了贪吃蛇。（贪心的楼主还是没办法改掉坏习惯，有是边做边学结构体、随机数、图形库画图等。度娘了链表由于完全看不懂动态链表，所以程序还是用了静态。图形库是EGE）

1. #include <graphics.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <time.h>
   
5. #define NULL 0
   
6. #define UP 1
   
7. #define DOWN 2
   
8. #define LEFT 3
   
9. #define RIGHT 4
   
10. int dir=RIGHT;
    
11. int num;
    
12. char direct;
    
13. struct link//定义蛇坐标（最大长度为60，不足部分为0，显示部分为1）
    
14. {
    
15.         int x;
    
16.         int y;
    
17.         int state;//0隐藏1显示
    
18.         struct link *next;
    
19. }snack[60];
    
20. struct link *head=&snack[0];
    
21. struct link *p;
    
22. struct loca
    
23. {
    
24.         int x;
    
25.         int y;
    
26.         int state;//没被吃为1，被吃为0
    
27. }food;
    
28. void initLink()
    
29. {
    
30.         int l;
    
31.         for(l=0;l<=1;l++)
    
32.         {
    
33.                 snack[l].next=&snack[l+1];
    
34.         }
    
35. }
    
36. void initSnack()
    
37. {
    
38.         int i;
    
39.         for(i=0;i<=2;i++)
    
40.         {
    
41.                 snack[i].x=400-(i-1)*10;
    
42.                 snack[i].y=300;
    
43.                 snack[i].state=1;
    
44.         }
    
45. 
    
46. }
    
47. void initFood()
    
48. {
    
49.         srand((unsigned int)time(NULL));
    
50.         food.x=rand()%80*10;
    
51.         food.y=rand()%60*10;
    
52.         food.state=1;
    
53. }
    
54. void drawSnack()
    
55. {
    
56.         p=head;
    
57.         for(;p!=NULL;)
    
58.         {       
    
59.                 setfillcolor(RED);
    
60.                 bar(p->x-4, p->y-4, p->x+4, p->y+4);
    
61.                 p=p->next;
    
62.         }
    
63. 
    
64. }
    
65. void funcFood()
    
66. {
    
67.         if(food.state==0)
    
68.         {
    
69.                 food.state=1;
    
70.                 food.x=rand()%80*10;
    
71.                 food.y=rand()%60*10;
    
72.         }
    
73.         setfillcolor(RED);
    
74.         bar(food.x-4,food.y-4,food.x+4,food.y+4);
    
75.         if(head->x==food.x&&head->y==food.y)//吃到食物，尾不变，加头
    
76.         {
    
77.                 num++;
    
78.                 food.state=0;
    
79.                 snack[num-1].next=head;
    
80.                 head=&snack[num-1];
    
81.         }
    
82.         else//没吃食物尾变头
    
83.         {
    
84.                 p=head;
    
85.                 int aa;
    
86.                 for(aa=1;aa<=num-2;aa++)//p指向倒数第二个链节
    
87.                 {
    
88.                         p=p->next;
    
89.                 }
    
90.                 p->next->next=head;//尾变头
    
91.                 head=p->next;
    
92.                 p->next=NULL;//完成
    
93.         }
    
94. }
    
95. void die()
    
96. {
    
97.                 if(head->x<0||head->y<0||head->x>800||head->y>600)
    
98.                         goto stop;
    
99.                 else
    
100.                 {
     
101.                         p=head->next;
     
102.                         for(;p!=NULL;)
     
103.                         {
     
104.                                 if(head->x==p->x&&head->y==p->y)
     
105.                                 {
     
106.                                         goto stop;
     
107.                                 }
     
108.                                 p=p->next;
     
109.                         }
     
110.                 }
     
111.                 p=head;
     
112.                 if(0)
     
113.                 {
     
114. stop:                for(;1;)
     
115.                                 getch;
     
116.                 }
     
117. }
     
118. void move()
     
119. {
     
120.         for(num=3;num<=60;)
     
121.         {
     
122.                 drawSnack();
     
123.                 funcFood();
     
124.                 if(kbhit())
     
125.                 {
     
126.                         direct=getch();
     
127.                         if(direct=='a'&&dir!=RIGHT)
     
128.                         {
     
129.                                 dir=LEFT;
     
130.                         }
     
131.                         else if(direct=='d'&&dir!=LEFT)
     
132.                                 dir=RIGHT;
     
133.                         else if(direct=='w'&&dir!=DOWN)
     
134.                                 dir=UP;
     
135.                         else if(direct=='s'&&dir!=UP)
     
136.                                 dir=DOWN;
     
137.                 }
     
138.                 if(dir==RIGHT)
     
139.                 {
     
140.                         head->x=head->next->x+10;
     
141.                         head->y=head->next->y;
     
142.                 }
     
143.                 else if(dir==LEFT)
     
144.                 {
     
145.                         head->x=head->next->x-10;
     
146.                         head->y=head->next->y;
     
147.                 }
     
148.                 else if(dir==UP)
     
149.                 {
     
150.                         head->y=head->next->y-10;
     
151.                         head->x=head->next->x;
     
152.                 }
     
153.                 else if(dir==DOWN)
     
154.                 {
     
155.                         head->y=head->next->y+10;
     
156.                         head->x=head->next->x;
     
157.                 }
     
158.                 Sleep(100);
     
159.                 die();
     
160.                 setfillcolor(BLACK);
     
161.                 bar(0,0,800,600);
     
162.         }
     
163. }
     
164. int main()
     
165. {
     
166.         initLink();//蛇链表创立
     
167.     initgraph(800, 600);
     
168.         initSnack();//初始化蛇的位置、长度
     
169.         initFood();//初始化食物
     
170.         move();//蛇
     
171.         closegraph();
     
172.         return 0;
     
173. }

复制代码