演示程序和源程序的区别

演示程序（Demo）和源程序（Source Code）是软件开发中两个不同概念：

1. 演示程序（Demo）：演示程序通常是一个简化版本的软件应用程序，它展示了软件的主要功能和特性。演示程序的设计目的是为了让用户能够直观地了解软件的使用方式和功能优势，而不是一个完整的应用程序。它可能缺少一些复杂的功能，或者在功能上有一些限制。演示程序可以是软件公司用来展示产品的一个营销工具，也可以是开发人员用来向潜在投资者或客户展示他们的想法或项目状态。

2. 源程序（Source Code）：源程序是指编写软件应用时所使用的原始代码，它是用某种编程语言编写的文本文件。源程序包含了实现软件功能的详细指令，包括算法、数据结构、用户界面定义和交互逻辑等。源代码需要通过编译或解释才能生成可执行的程序，这是软件开发过程的核心部分。源代码的管理通常涉及到版本控制、代码审查和单元测试等环节。

相关问题

用c语言写一个贪吃蛇游戏”的说明如下：（参照演示程序和源程序框架）启动程序时，输入的用户名如果以前没有，则系统自动完成注册，如果有，则进行密码比较以判断是否允许登录。用户名将用于英雄榜中。

好的，这是一个比较复杂的问题。首先，你需要了解贪吃蛇游戏的规则和逻辑，然后你需要学习如何使用C语言进行编程。

以下是一个简单的贪吃蛇游戏的源程序框架，可以帮助你开始编写你自己的贪吃蛇游戏：

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

#define MAX_X 20
#define MAX_Y 20

enum direction {UP, DOWN, LEFT, RIGHT};

struct snake {
  int x;
  int y;
  struct snake *next;
};

struct snake *head, *tail;
int food_x, food_y;
enum direction dir = RIGHT;
int score = 0;
char username[20];

void init_game();
void init_snake();
void init_food();
void display();
void update();
void game_over();
void save_score();
int check_collision(int x, int y);
void register_user();
void login();

int main() {
  int choice;
  printf("Welcome to Snake Game!\n");
  printf("1. Register\n");
  printf("2. Login\n");
  printf("Enter your choice: ");
  scanf("%d", &choice);
  if (choice == 1) {
    register_user();
  } else if (choice == 2) {
    login();
  } else {
    printf("Invalid choice!\n");
    exit(0);
  }
  init_game();
  while (1) {
    display();
    update();
    Sleep(100);
  }
  return 0;
}

void init_game() {
  srand(time(NULL));
  init_snake();
  init_food();
}

void init_snake() {
  head = (struct snake*) malloc(sizeof(struct snake));
  tail = (struct snake*) malloc(sizeof(struct snake));
  head->x = 3;
  head->y = 1;
  head->next = tail;
  tail->x = 1;
  tail->y = 1;
  tail->next = NULL;
}

void init_food() {
  food_x = rand() % MAX_X + 1;
  food_y = rand() % MAX_Y + 1;
}

void display() {
  system("cls");
  printf("Score: %d\n", score);
  for (int i = 0; i < MAX_X; i++) {
    for (int j = 0; j < MAX_Y; j++) {
      if (i == head->x && j == head->y) {
        printf("O");
      } else if (i == food_x && j == food_y) {
        printf("*");
      } else {
        int found = 0;
        struct snake *ptr = head->next;
        while (ptr != tail) {
          if (ptr->x == i && ptr->y == j) {
            printf("o");
            found = 1;
            break;
          }
          ptr = ptr->next;
        }
        if (!found) {
          printf(" ");
        }
      }
    }
    printf("\n");
  }
}

void update() {
  int new_x = head->x, new_y = head->y;
  switch (dir) {
    case UP:
      new_x--;
      break;
    case DOWN:
      new_x++;
      break;
    case LEFT:
      new_y--;
      break;
    case RIGHT:
      new_y++;
      break;
  }
  if (check_collision(new_x, new_y)) {
    game_over();
    return;
  }
  struct snake *new_head = (struct snake*) malloc(sizeof(struct snake));
  new_head->x = new_x;
  new_head->y = new_y;
  new_head->next = head;
  head = new_head;
  if (new_x == food_x && new_y == food_y) {
    score++;
    init_food();
  } else {
    struct snake *ptr = head;
    while (ptr->next != tail) {
      ptr = ptr->next;
    }
    struct snake *old_tail = tail;
    tail = ptr;
    free(old_tail);
  }
}

void game_over() {
  printf("Game over! Your score is %d.\n", score);
  save_score();
  exit(0);
}

void save_score() {
  FILE *fp;
  fp = fopen("high_scores.txt", "a");
  fprintf(fp, "%s %d\n", username, score);
  fclose(fp);
}

int check_collision(int x, int y) {
  if (x < 0 || x >= MAX_X || y < 0 || y >= MAX_Y) {
    return 1;
  }
  struct snake *ptr = head->next;
  while (ptr != tail) {
    if (ptr->x == x && ptr->y == y) {
      return 1;
    }
    ptr = ptr->next;
  }
  return 0;
}

void register_user() {
  char password[20], confirm[20];
  FILE *fp;
  fp = fopen("users.txt", "a+");
  printf("Enter your username: ");
  scanf("%s", username);
  while (!feof(fp)) {
    char name[20], pass[20];
    fscanf(fp, "%s %s", name, pass);
    if (strcmp(username, name) == 0) {
      printf("Username already exists!\n");
      fclose(fp);
      exit(0);
    }
  }
  printf("Enter your password: ");
  scanf("%s", password);
  printf("Confirm your password: ");
  scanf("%s", confirm);
  if (strcmp(password, confirm) != 0) {
    printf("Passwords do not match!\n");
    fclose(fp);
    exit(0);
  }
  fprintf(fp, "%s %s\n", username, password);
  fclose(fp);
}

void login() {
  char password[20];
  FILE *fp;
  fp = fopen("users.txt", "r");
  printf("Enter your username: ");
  scanf("%s", username);
  while (!feof(fp)) {
    char name[20], pass[20];
    fscanf(fp, "%s %s", name, pass);
    if (strcmp(username, name) == 0) {
      printf("Enter your password: ");
      scanf("%s", password);
      if (strcmp(password, pass) != 0) {
        printf("Incorrect password!\n");
        fclose(fp);
        exit(0);
      }
      fclose(fp);
      return;
    }
  }
  printf("Username does not exist!\n");
  fclose(fp);
  exit(0);
}

这个程序包含了很多功能，包括注册、登录、保存分数、检查碰撞等等。你可以按照程序框架，编写自己的贪吃蛇游戏程序。

用c语言写算术表达式求值程序。演示程序和源程序已给出。用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。 编写源程序中的 double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果。要求用两个栈，一个储存数字，一个储存运算符

以下是用C语言实现算术表达式求值程序的源代码：

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

#define MAX_STACK_SIZE 100

typedef struct {
    int top;
    int data[MAX_STACK_SIZE];
} Stack;

void push(Stack *s, int x) {
    if (s->top == MAX_STACK_SIZE - 1) {
        printf("Stack overflow\n");
        exit(1);
    }
    s->data[++s->top] = x;
}

int pop(Stack *s) {
    if (s->top == -1) {
        printf("Stack underflow\n");
        exit(1);
    }
    return s->data[s->top--];
}

int is_empty(Stack *s) {
    return s->top == -1;
}

int peek(Stack *s) {
    return s->data[s->top];
}

int priority(char op) {
    if (op == '+' || op == '-') {
        return 1;
    } else if (op == '*' || op == '/') {
        return 2;
    } else {
        return 0;
    }
}

double deal_exp(char *exp) {
    Stack num_stack, op_stack;
    int num = 0;
    double result = 0.0;
    int sign = 1;
    num_stack.top = op_stack.top = -1;

    while (*exp != '\0') {
        if (isdigit(*exp)) {
            num = num * 10 + (*exp - '0');
        } else if (*exp == '-') {
            if (isdigit(*(exp + 1))) {
                sign = -1;
            } else {
                push(&num_stack, num * sign);
                num = 0;
                sign = 1;
            }
        } else {
            push(&num_stack, num * sign);
            num = 0;
            sign = 1;

            while (!is_empty(&op_stack) && priority(peek(&op_stack)) >= priority(*exp)) {
                int b = pop(&num_stack);
                int a = pop(&num_stack);
                char op = pop(&op_stack);

                switch (op) {
                    case '+':
                        push(&num_stack, a + b);
                        break;
                    case '-':
                        push(&num_stack, a - b);
                        break;
                    case '*':
                        push(&num_stack, a * b);
                        break;
                    case '/':
                        push(&num_stack, a / b);
                        break;
                }
            }
            push(&op_stack, *exp);
        }
        exp++;
    }

    push(&num_stack, num * sign);

    while (!is_empty(&op_stack)) {
        int b = pop(&num_stack);
        int a = pop(&num_stack);
        char op = pop(&op_stack);

        switch (op) {
            case '+':
                push(&num_stack, a + b);
                break;
            case '-':
                push(&num_stack, a - b);
                break;
            case '*':
                push(&num_stack, a * b);
                break;
            case '/':
                push(&num_stack, a / b);
                break;
        }
    }

    result = pop(&num_stack);
    if (!is_empty(&num_stack) || !is_empty(&op_stack)) {
        printf("Invalid expression\n");
        exit(1);
    }

    return result;
}

int main() {
    char exp[100];
    double result;

    printf("Enter an expression: ");
    scanf("%s", exp);

    result = deal_exp(exp);
    printf("Result: %g\n", result);

    return 0;
}

该源代码中，首先定义了一个栈结构体和相关的栈操作函数。其中，push()函数用于将元素入栈，pop()函数用于将元素出栈，is_empty()函数用于判断栈是否为空，peek()函数用于返回栈顶元素的值，priority()函数用于返回运算符的优先级。

然后，定义了deal_exp()函数，该函数用于对算术表达式求值。该函数使用了两个栈，一个用于存储数字，一个用于存储运算符。在函数中，首先将num_stack和op_stack的top值初始化为-1，并定义了num、result和sign变量。num变量用于存储当前正在处理的数字，result变量用于存储最终的结果，sign变量用于存储数字的符号。

接下来，使用while循环遍历算术表达式的每个字符。如果遇到数字，则将其累加到num变量中；如果遇到负号，则判断下一个字符是否为数字，如果是，则将sign变量设为-1，否则将num变量入栈，并将sign变量设为1；如果遇到运算符，则将num变量入栈，并将num变量设为0和sign变量设为1。然后，使用while循环将op_stack中优先级高于或等于当前运算符的运算符弹出，并对num_stack中的数字进行相应的计算，直到op_stack为空或其栈顶运算符优先级低于当前运算符。最后，将当前运算符入op_stack栈。

当遍历完整个算术表达式后，将num变量入栈。然后，使用while循环将op_stack中的所有运算符弹出，并对num_stack中的数字进行相应的计算。最终，将num_stack中的最后一个数字作为结果返回，并检查num_stack和op_stack是否为空。如果不为空，则说明算术表达式不合法。

在main()函数中，首先从标准输入读取算术表达式，然后调用deal_exp()函数求值，并输出结果。