Solicitud urgente: diseñar un informe de experimento con serpientes
Diseño del plan de estudios del estudiante (Tesis)
Tema: Guía de programación del juego Snake
Nombre del estudiante: ID del estudiante: 200910801001
Escuela (Departamento) ): Facultad de Ciencias de la Computación
Especialidad: Ciencias de la Computación y Tecnología
Clase: Clase 1, 2009
Instructor: He Chunyan Título: Profesor
18 de junio de 2010
Contenido
Resumen……………………………………………………………… 6
1. Requisitos de diseño…………………………………….7
2. Instrumentos y equipos utilizados………… ……………… ………………………….7
3. Proceso de diseño específico………………………………………….8.
3.1 Funciones del programa…………………………………………8
3.2 Ideas de diseño……………………………… ………8
3.3. Implementación específica del diseño…………………………………………8.
3.4 Diagrama de flujo general………………………………………… .14
3.5. Escritura y anotación del código del programa………………..15
3.6 Problemas de depuración y soluciones………… …………21
3.7 Resultados de la depuración………………………………………….22.
4 Experiencia en diseño………… ………………………… ……………………25.
5 Referencias…………………………………………..26
Resumen
Escriba un programa en lenguaje C para implementar el Juego de la Serpiente. El Juego de la Serpiente es un juego popular. Una serpiente está en una pared cerrada y aparece una serpiente al azar en la pared. Para comer, presione las cuatro teclas de cursor en la pared. teclado para controlar que la serpiente se mueva hacia arriba, abajo, izquierda y derecha. Si la cabeza de la serpiente golpea la comida, significa que la serpiente se ha comido la comida. En este momento, el cuerpo de la serpiente crecerá en una sección y 10. Los puntos se contarán al mismo tiempo. La comida aparece y está esperando ser comida por la serpiente. Si la serpiente golpea una pared o cruza su cuerpo mientras se mueve, la cabeza de la serpiente golpea su propio cuerpo y el juego termina. Como programa completo, especialmente un juego completo, se debe considerar la comunicación persona-computadora y la experiencia del usuario. La interfaz del juego no puede ser demasiado fea y ni siquiera puede tener una interfaz sencilla. El juego debe tener una interfaz relativamente hermosa. Con el soporte de hardware y software necesario, los desarrolladores del juego deben hacer que el juego sea lo más hermoso posible. La belleza del juego es una cosa y la calidad intrínseca del juego es otra. La calidad de un juego la determinan en última instancia los jugadores. Antes de que el juego llegue a los jugadores, los desarrolladores del juego deben diseñar un modo de juego que permita a los jugadores invertir y jugar bajo ciertas reglas del juego.
Palabras clave Diagrama de flujo de Snake lenguaje c programa fuente turbo C
Programación de juegos Snake
1. Requisitos de diseño
A través de la programación de juegos, mejorar. interés en programación e ideas de programación, consolidar los conocimientos aprendidos en lenguaje C, utilizar materiales de manera razonable y lograr la combinación de teoría y práctica.
(1). Recopilar información, analizar el tema, descomponer el problema y formar una idea de diseño general;
(2). Análisis en profundidad de cada pequeño problema, esquema y redacción de varios módulos del programa;
(3). Para las funciones clave utilizadas en el diseño, debe aprender a buscar información para comprender su uso y proporcionar introducciones detalladas en relación con el problema;
(4). Depurar en la computadora, verificar errores y analizar gradualmente los motivos de la falla para ejecutarse normalmente, para garantizar que el programa diseñado sea correcto y pueda ejecutarse normalmente;
(5). Completar el informe de diseño del curso y realizar la defensa
El lenguaje C es un lenguaje de programación general fácil de aprender y comprender. Debido a que es altamente funcional, fácil de usar y flexible, tiene las ventajas de ambos. Lenguajes de alto y bajo nivel. Además de las características de "alta eficiencia del programa objetivo", portabilidad e implementación universal en varios sistemas, se ha convertido en uno de los lenguajes de programación más importantes del mundo actual. ha sido seleccionado como un idioma ampliamente utilizado en el mundo y también es una materia obligatoria para los estudiantes universitarios. Como estudiante universitario contemporáneo, debemos aprovecharlo, aprender bien un lenguaje de diseño y aplicar lo que hemos aprendido.
Hacer un informe del programa C puede consolidar y profundizar su comprensión y dominio de los conocimientos básicos de los cursos de lenguaje C, y dominar las habilidades básicas de programación y depuración de programas en lenguaje C.
A través de la capacitación en diseño de programas de juegos, puede mejorar sus habilidades básicas y dominar mejor los métodos de representación de cadenas y las funciones de las funciones de cadenas, conocimientos básicos de las operaciones de gráficos Tc, adquisición de teclas especiales en el teclado y Muestre el cursor en modo gráfico, mejore su interés y nivel de programación, aprenda a escribir correctamente documentación de programación, mejore su capacidad para usar el lenguaje C para resolver problemas prácticos, consolide la comprensión y el dominio de las reglas gramaticales del lenguaje C y aprenda a escribir código fuente. programas Dibuje diagramas de flujo para mejorar su capacidad de autoestudio y acceso a la información.
2. Instrumentos y equipos utilizados
1. Una computadora que pueda funcionar normalmente;
3.
3. Proceso de diseño específico
3.1. Funciones del programa
El juego de la Serpiente es un minijuego clásico. Una serpiente está en una pared cerrada. La pared es aleatoria. Cuando aparece un trozo de comida, presione las cuatro teclas de cursor en el teclado para controlar que la serpiente se mueva hacia arriba, abajo, izquierda y derecha. Si la cabeza de la serpiente derriba la comida, la comida se la comerá. El cuerpo crecerá en una sección y se registrarán 10 puntos al mismo tiempo. Luego, la comida aparecerá nuevamente y la serpiente la esperará y comerá si la serpiente golpea la pared mientras se mueve o la cabeza de la serpiente con el tenedor del cuerpo golpea. bajando por su propio cuerpo el juego ha terminado.
3.2 Idea de diseño
La clave del programa es representar la forma de la serpiente y su movimiento. Utilice un rectángulo pequeño para representar un segmento del cuerpo de la serpiente. Para cada segmento del cuerpo, agregue un bloque rectangular. La cabeza de la serpiente está representada por dos segmentos. El movimiento debe comenzar desde la cabeza de la serpiente, por lo que la serpiente no puede moverse en la dirección opuesta. Si no presiona ninguna tecla, la serpiente avanzará en la dirección actual por sí sola. Sin embargo, después de presionar la tecla de dirección válida, la serpiente. La cabeza de la serpiente se moverá en esa dirección, moviendo una sección en un solo paso, por lo que después de presionar la tecla de dirección válida, primero determine la posición de la cabeza de la serpiente, y luego el cuerpo de la serpiente se mueve con la cabeza de la serpiente. dibujando la serpiente desde la nueva posición de la cabeza de la serpiente. En este momento, debido a que la pantalla no se borra, la posición de la serpiente original es una unidad diferente de la posición de la nueva serpiente, por lo que se parece a la serpiente. tiene una sección más del cuerpo, por lo que la última sección de la serpiente está cubierta con el color de fondo. La aparición y desaparición de los alimentos también están dibujadas y cubiertas por bloques rectangulares. Para facilitar la comprensión, se definen dos estructuras: comida y serpiente.
3.3. Implementación específica del diseño
(1) Definición de función
La definición de función es la definición de cada función básica y establece la información que debe usarse para facilitar la llamada
# define N 200
#include
#include
#include
#define LEFT 0x4b00/*Valor de la tecla del cursor izquierdo*/
#define DERECHA 0x4d00/*Valor de clave del cursor derecho*/
#define DOWN 0x5000/*Valor de clave debajo del cursor*/
#define UP 0x4800/*Valor de clave encima del cursor*/
# define ESC 0x011b/*Código ASCII de ESC*/
int i,key;/*Variables de coordenadas gráficas y variables clave*/
int puntuación =0;/*Puntuación*/
int gamespeed=10000;/*ajustar la velocidad del juego*/
estructurar comida
{
int x;/*food La abscisa de */
int y;/*La ordenada de la comida*/
int yes;/*Variable para determinar si la comida debe aparecer */
}comida;/*Estructura alimentaria*/
struct Snake
{
int x[];/*Snake's abscisa*/
int y[];/*La coordenada vertical de la serpiente*/
int node;/*El número de nodos de la serpiente*/
int dirección;/*Dirección del movimiento de la serpiente*/
int vida;/*Vida de la serpiente, 0 viva, 1 muerta*/
}serpiente;
void Init(void); /*Controlador de gráficos*/
void Close(void);/*Fin del gráfico*/
void DrawK(void);/*Interfaz de dibujo function*/
void GameOver(void);/*Finalizar el juego*/
void GamePlay(void);/*El proceso específico de jugar el juego*/
void PrScore(void);/* Resultados de salida*/
void main(void)/*función principal*/
(2) Función principal main()
La función principal es la función principal del programa. El proceso primero define las constantes, las variables globales y las descripciones de los prototipos de funciones utilizadas, luego inicializa el sistema de gráficos, llama a la función DrawK() para dibujar la pantalla de inicio, llama la función GamePlay(), que es el proceso específico de jugar el juego, y llama a Close() una vez finalizado el juego. Cierra el sistema de gráficos y finaliza el programa
void main(void)/*. función principal*/
{
Init();/*controlador de gráficos*/
DrawK();/*Pantalla de inicio*/
GamePlay();/*El proceso específico de jugar el juego*/
Close();/*Fin de gráficos*/
}
void Init(void)/*Controlador de gráficos*/
{
int gd=DETECT,gm ;
initgraph(&gd,&gm,"c:\ \tc"); /*El primer parámetro indica el tipo de adaptador de gráficos, el segundo parámetro es el modo de visualización de los gráficos de este tipo y el tercer parámetro Cada parámetro especifica el directorio donde se encuentra el controlador.
*/
cleardevice();
}
(3) La función de interfaz de dibujo DrawK()
La interfaz principal es una cerrado Para la cerca, se utilizan dos declaraciones de bucle para generar bloques rectangulares continuos de igual ancho y alto en las direcciones horizontal y vertical respectivamente, que representan la cerca. Para que sea llamativo, se establece en blanco.
void DrawK(void)/*Pantalla de inicio, las coordenadas de la esquina superior izquierda son (50, 40), las coordenadas de la esquina inferior derecha son (610, 460) pared*/
{
setbkcolor(0);/*Establecer el color de fondo actual*/
setcolor(YELLOW);/*Establecer el color de línea actual*/
setlinestyle(SOLID_LINE, 0,THICK_WIDTH);/*Establecer tipo de línea*/
for(i=50;i<=600;i+=10)/*Dibujar valla*/
{
rectangle(i,40,i+10,49); /*borde superior*/
rectangle(i,451,i+10,460);/*borde inferior */
}
for(i=40;i<=450;i+=10)
{
rectángulo(50 ,i,59,i +10); /*izquierda*/
rectangle(601,i,610,i+10);/*derecha*/
}
}
(4) Función de proceso específica del juego GamePlay()
Este es el componente principal del juego. Asigna las coordenadas de la sección anterior a la siguiente. sección y usa el color de fondo para La última sección se elimina. Cuando las coordenadas de la cabeza de la serpiente son iguales a las coordenadas de la comida, significa que la comida se ha comido.
void GamePlay(void)/*El proceso específico de jugar el juego*/
{
randomize();/*Generador de números aleatorios*/
food.yes=1;/*1 significa que es necesario que aparezcan nuevos alimentos, 0 significa que los alimentos ya existen*/
snake.life=0;/*alive*/
snake.direction=1;/*dirección a la derecha*/
snake.x[0]=100;snake.y[0]=100;/*cabeza de serpiente*/
snake.x[1]=110;snake.y[1]=100;/*Snake Sección 2*/
snake.node=2;/*Número de secciones* /
PrScore();/*Puntuación de salida*/
while(1)/*Puedes jugar el juego repetidamente y presionar la tecla ESC para finalizar*/
{
while(!kbhit())/*La serpiente mueve su cuerpo sola sin presionar un botón*/
{
if( food.yes==1)/* Es necesario que aparezcan nuevos alimentos*/
{
food.x=rand()%4060;
food.y=rand()%35 60;
while(food.x%10!=0)/*Después de que la comida aparezca aleatoriamente, la comida debe estar dentro de toda la cuadrícula para que la serpiente puedo comerlo*/
food.x++;
while(food.y%10!=0)
food.y++;
food.yes=0;/*Pantalla Hay comida en la pantalla*/
}
if(food.yes==0)/*Si hay comida en en la pantalla, se mostrará*/
{
setcolor(GREEN);/*Color de la comida*/
rectangle(food.x,food .y,comida.x+10,comida.y-10);
}
for(i=snake.node-1;i>0;i--)/ *Cada eslabón de la serpiente avanza, el algoritmo clave de la serpiente codiciosa* /
{
snake.x[i]=snake.x[i-1];
snake.y[i]=snake.y[ i-1];
}
cambiar(snake.direction) /*definir 1, 2, 3, 4 para representar las cuatro direcciones: derecha, izquierda, arriba y abajo. A través de este juez para mover la cabeza de serpiente*/
{
caso 1: serpiente.x[0. ]+=10;romper;
caso 2: serpiente.x[ 0]-=10;romper;
caso 3: serpiente.y[0]-=10;romper ;
caso 4: serpiente.y[0]+=10; romper;
}
for(i=3;i { if(serpiente.x[i]==serpiente.x[0]&&serpiente.y[i]= =serpiente.y[0]) { GameOver();/*Error de visualización*/ snake.life=1; rotura; } } if(snake.x[0]<55||snake.x[0]>595|| Snake.y[0]<55||snake.y[0]>455)/*Si el serpiente chocó contra la pared*/ { G ameOver();/*Este juego ha terminado*/ snake.life=1; /*La serpiente muere*/ } if(snake. life==1)/*Después de los dos juicios anteriores, si la serpiente muere, salta del bucle interno y comienza de nuevo*/ break; if(snake.x [0]= =food.x&&snake.y[0]==food.y)/*Después de comer la comida*/ { setcolor(0);/*Cambiar el comida en la pantalla Quitar cosas*/ rectangle(food.x,food.y,food.x+10,food.y-10); snake.x[snake .node]= -20;snake.y[snake.node]=-20; /*-20 significa que la cola es una sección más larga*/ /*La nueva sección se coloca en una posición invisible primero y el siguiente ciclo Simplemente tome la posición de la sección anterior*/ snake.node++;/*El cuerpo de la serpiente es una sección más larga*/ food.yes=1 ;/*Es necesario que aparezca una nueva sección en la pantalla comida*/ score+=10; PrScore();/*Salir nueva puntuación*/ } setcolor( 4); for(i=0;i rectángulo (serpiente.x[i],serpiente.y [i],serpiente.x[i]+10, serpiente.y[i]-10); retraso( gamespeed); setcolor (0);/*Elimina la última sección de la serpiente con negro*/ rectangle(snake.x[snake.node-1],snake. y[snake.node-1], snake.x[snake.node-1]+10,snake.y[snake.node-1]-10); } /*end while(!kbhit)*/ if(snake.life==1)/*Si la serpiente muere, sal del bucle*/ romper ; key=bioskey(0);/* Recibir clave*/ if(key==ESC)/*Presione ESC para salir*/ break; else if(key==UP&&snake.direction!=4) /*Determina si se debe mover en la dirección opuesta*/ snake.direction=3; else if(key==RIGHT&&snake.direction!=2) snake.direction=1 ; else if( key==IZQUIERDA&&snake.direction!=1) snake.direction=2; else if(key==ABAJO&&snake.direction!=3) snake.direction=4; }/*end while(1)*/ } (5) Función de finalización del juego GameOver( ) El juego finaliza, borra la pantalla, muestra la puntuación y muestra la información de finalización del juego. void GameOver(void)/*Juego terminado*/ { cleardevice(); PrScore(); p> setcolor(RED); settextstyle(0,0,4); outtextxy(200,200,"guojian"); getch (); } void PrScore(void)/*puntuación de salida*/ { char str[10]; setfillstyle(SOLID_FILL, WHITE); bar(50,15,200,35); setcolor(6); settextstyle (0,0,2); sprintf(str,"score:%d",score); outtextxy(55,20,str); } void Close(void)/*Fin del gráfico*/ { getch(); closegraph() ; } 3.4 Diagrama de flujo general } 3.5, escritura del código del programa y comentarios # definir N 200 #include #include #include #define IZQUIERDA 0x4b00 #define DERECHA 0x4d00 #define ABAJO 0x5000 #define ARRIBA 0x4800 #define ESC 0x011b int i,key; int score=0;/*score*/ int gamespeed=50000;/*ajustar el velocidad del juego*/ struct Food { int x;/*La abscisa de la comida*/ int y; /*La ordenada del alimento */ int yes;/*Variable para determinar si debe aparecer el alimento*/ }alimento;/*Estructura del alimento*/ estructura Serpiente { int x[N]; int y[N]; int nodo;/ *El número de nodos de la serpiente */ int dirección;/*Dirección de movimiento de la serpiente*/ int vida;/* Vida de la serpiente, 0 viva, 1 muerta*/ } serpiente; void Init(void);/*Controlador de gráficos*/ void Close(void);/*Fin del gráfico*/ void DrawK( void);/*Pantalla de inicio*/ void GameOver(void);/*Finalizar el juego*/ void GamePlay(void);/ *El proceso específico de jugar*/ void PrScore(void);/*Puntuación de salida*/ /*Función principal*/ void main(void) { Init();/*Controlador de gráficos*/ DrawK();/*Pantalla de inicio*/ GamePlay();/*Jugar juegos Proceso específico*/ Cerrar( );/*Fin del gráfico*/ } /*Controlador gráfico*/ void Init(void) { int gd=DETECT,gm; initgraph(&gd,&gm,"c:\\tc"); cleardevice(); } /*Inicie la pantalla, las coordenadas de la esquina superior izquierda son (50, 40), las coordenadas de la esquina inferior derecha son (610, 460) pared */ void DrawK(void ) { /*setbkcolor(LIGHTGREEN);*/ setcolor(11); setlinestyle( SOLID_LINE,0, THICK_WIDTH);/*Establecer tipo de línea*/ for(i=50;i<=600;i+=10)/*Dibujar valla*/ { rectangle(i,40,i+10,49); /*borde superior*/ rectangle(i,451,i+10,460);/*borde inferior*/ } for(i=40;i<=450;i+=10) { rectángulo(50,i ,59,i+10 ); /*izquierda*/ rectangle(601,i,610,i+10);/*derecha*/ } } /*El proceso específico de jugar el juego*/ void GamePlay(void) { aleatorizar ();/*Generador de números aleatorios */ food.yes=1;/*1 significa que es necesario que aparezcan nuevos alimentos, 0 significa que los alimentos ya existen*/ snake.life =0;/*alive*/ snake.direction=1;/*dirección a la derecha*/ snake.x[0]=100;snake.y[0 ]=100;/*cabeza de serpiente*/ snake.x[1]=110;snake.y[1]=100; snake.node=2;/* número de nodos*/ PrScore();/*Puntuación de salida*/ while(1)/*Puedes jugar el juego repetidamente y presionar la tecla ESC para finalizar*/ { mientras (!kbhit())/*Sin presionar un botón, la serpiente mueve su cuerpo por sí sola*/ { if(food.yes==1)/*Es necesario que aparezcan nuevos elementos Comida*/ { food.x=rand()%4060; food.y=rand()%3560; while(food.x%10!=0)/*Después de que la comida aparezca aleatoriamente, la comida debe estar dentro de todo el rejilla para que la serpiente pueda comerlo*/ comida x++; while(food.y%10!=0) comida.y++; food.yes=0;/*Hay comida en la pantalla */ } if(food.yes==0)/*Si hay comida en la pantalla, se mostrará*/ { setcolor(GREEN); rectangle(food.x,food.y, food.x+10,food.y-10); } for(i=snake.node-1;i>0;i--)/*Cada enlace de la serpiente avanza, que es el algoritmo clave de la serpiente codiciosa*/ { snake.x[i]=snake.x[i-1]; > snake.y[i]=snake.y[i-1]; } /*1,2,3,4 significa derecha, izquierda, arriba , las siguientes cuatro direcciones, use este criterio para mover la cabeza de serpiente*/ switch(snake.direction) { caso 1: serpiente.x [0 ]+=10;romper; caso 2: serpiente.x[0]-=10;romper; caso 3: serpiente.y[0]-=10 ;break ; caso 4: serpiente.y[0]+=10;break; } for(i=3;i { if( serpiente.x[i]==serpiente.x[0]&&snake.y[i]==serpiente.y[0]) { GameOver();/* Error de visualización*/ snake.life=1; rotura; } } if (snake.x[0]<55||snake.x[0]>595||snake.y[0]<55|| snake.y [0]>455)/*serpiente Si golpeó la pared*/ { GameOver();/*Este juego ha terminado*/ Snake.life=1; /*La serpiente muere */ } if(snake.life==1)/*Después de los dos juicios anteriores, si la serpiente muere, salta salir del bucle interno y comenzar de nuevo*/ break; if(snake.x[0]==food.x&&snake.y[0]==food.y) /*después de comer*/ { setcolor(0);/*Eliminar la comida de la pantalla*/ rectangle(food.x, comida.y,comida.x+10,comida y-10); snake.x[snake.node]=-20;snake.y[snake.node]=-20; /*Nueva sección primero Colóquela en una posición invisible, y el siguiente ciclo tomará la posición de la sección anterior*/ snake.node++;/*El cuerpo de la serpiente es una sección long*/ food.yes =1;/*Es necesario que aparezca comida nueva en la pantalla*/ score+=10; PrScore(); /*Generar nueva puntuación*/ } setcolor(4);/*Dibujar una serpiente*/ for(i=0;i rectángulo( serpiente.x[i],serpiente.y[i],serpiente.x[i]+10, serpiente.y[i] -10); delay(gamespeed ); setcolor(0);/*Elimina la última sección de la serpiente con negro*/ rectangle( serpiente.x[snake.node-1],snake.y [snake.node-1], snake.x[snake.node-1]+10,snake.y[snake.node- 1]-10); } /*end while(! kbhit)*/ if(snake.life==1)/*Si la serpiente muere, sal del bucle*/ break; > key=bioskey(0);/*Recibir clave*/ if(key==ESC)/*Presione ESC para salir*/ break; else if(key==UP&&snake.direction!=4) /*Determinar si moverse en la dirección opuesta*/ serpiente.direction=3; else if(key==RIGHT&&snake.direction!=2) snake.direction=1; else if(key==LEFT&&snake.direction!=1) snake.direction=2; else if(key==DOWN&&snake.direction!=3) snake.direction=4; }/*end while(1)*/ } /*Game over*/ 3.6 Problemas de depuración y soluciones Al copiar el programa modificado a Turbo C, debido al contenido excesivo del software A menudo habrá un desplazamiento a la derecha, de modo que la mayor parte del contenido no se puede copiar a la interfaz Turbo C y, en última instancia, el software no se puede ejecutar. Solución: al cambiar el programa, debe configurar bien el formato, prestar atención a la alineación a la izquierda y mantener las declaraciones en una línea lo más corta posible. Es mejor que una declaración ocupe una línea. Después de ingresar el programa en TC, compilar y ejecutar el programa fuente, encontramos muchos errores en el programa, como se muestra en la siguiente figura: Puedes seguir las indicaciones de error cuando ejecutando el programa Al modificar el programa original, a veces encontré problemas que no entendí durante el proceso de depuración. Fui a la biblioteca o a Internet para verificar alguna información o le pedí consejo al maestro y resolví el problema modificando. el programa fuente uno por uno hasta que se ejecutó exitosamente. 3.7 Resultados de la depuración 1. La siguiente imagen muestra los resultados de la depuración y compilación del programa: 2 La siguiente imagen muestra los resultados de la depuración y ejecución del programa (es decir, la interfaz del juego Snake) 4 Experiencia de diseño Después de solo dos semanas de pasantía en tecnología de software, tengo una comprensión más profunda de los programas C. Solía pensar que el lenguaje C es aburrido. y pensé que los programas que diseñamos eran de poca utilidad, pero ahora, al diseñar el programa Snake Game, entiendo cómo aplicar el conocimiento que aprendí en la vida. Aunque no entendía muy bien cómo diseñar el programa cuando comencé a diseñarlo, después de leer la "Compilación de casos de diseño de cursos en lenguaje C" y crear este programa serpiente en lenguaje C, sentí profundamente la magia de la programación en C. Al diseñar este programa, aprendí principalmente a utilizar los siguientes conocimientos sobre el lenguaje C 1) Es muy importante que la definición de la función sea como su nombre lo indica. es muy importante para leer el programa. Es muy importante que las personas comprendan correctamente el programa. En el proceso de modificación del programa, uno puede descubrir rápidamente las funciones de cada módulo del programa, lo cual es en gran medida. aumenta la legibilidad del programa . 2) Para analizar la función, comience con la función main(). La función Main() es el comienzo de la compilación del programa fuente C. Leer funciones a partir de la función main() puede ayudarle a comprender las funciones de otras funciones más a fondo. 3) Al crear un programa, primero delinee el marco, analice el propósito (función) del programa, elija la estructura de datos correcta y luego modularice el programa, es Es más sencillo y razonable escribir funciones según módulos. 4) También aprendí sobre las funciones de muchas funciones de la biblioteca. Por ejemplo, entre las funciones de cadena, hay muchas funciones que procesan cadenas y entiendo sus funciones. Al mismo tiempo, también adquirí mucha experiencia valiosa: 1) Antes de diseñar un programa, debes tener una comprensión sistemática del tema y el contenido que estás diseñando. Conoce qué recursos se incluyen en los temas y contenidos diseñados. 2) No es muy importante qué lenguaje de programación se utiliza para diseñar el programa. La clave es tener una idea clara y un diagrama de flujo de software completo. Es necesario combinar primero los principios de diseño con Una vez que las ideas estén claras y el proceso esté dibujado, el diseño será mucho más simple. 3) Al diseñar un programa, no se puede diseñar todo el programa de una sola vez. "Las modificaciones repetidas y la mejora continua " son la única forma de diseñar un programa. errores, también es una especie de logro. 4) Desarrolla el buen hábito de comentar programas. La perfección de un programa no se trata sólo de su función, sino que las personas deben poder entender tus ideas de un vistazo. Esto también proporciona comodidad para el almacenamiento e intercambio de datos. 5. Referencias 1. Guo Cuiying, "Recopilación de casos de diseño de cursos de lenguaje C", China Water Conservancy and Hydropower Press, 2004.3 2 Xu Jinwu , Yang Debin, etc., "TURBO C Practical Encyclopedia", Mechanical Engineering Press, 1996.5 3 Li Lijuan "Tutorial de programación en lenguaje C" People's Posts and Telecommunications Press 4 Lin Huacong " Pensamientos y práctica de programación en lenguaje C "Prensa de la industria metalúrgica 5 Zhang Jiwen "Tutorial de programación en lenguaje C" Prensa de educación superior 6 Pan Yunhe, Dong Jinxiang, etc. Gráficos por computadora: principios, métodos y aplicaciones. Beijing: Higher Education Press, 2003.12 7 Sun Jiaguang et al., Computer Graphics (tercera edición), Tsinghua University Press, 2004 8 Editado por Chen Yuanyan. Tecnología práctica de gráficos por computadora. Beijing: Science Press, 2000 9 Escrito por He Qingfang. Tutorial de algoritmos y principios de gráficos por computadora. Beijing: Tsinghua University Press 10 Tutorial de dibujo en lenguaje C Beijing: Tsinghua University Press, 1996