C基础系列教程 – HYL Studio

2019C语言题目3

做点有意思的


1.打印下列图形
|  1 2 3|
|1      |
|2      |
|3      |

|  1 2 3|
|1 x x x|
|2 x x x|
|3 x x x|

|  1 2 3|
|1 o o o|
|2 o o o|
|3 o o o|

2.在1的基础上，根据输入的坐标(x,y)打印图形
超出范围提示输入错误
例如输入(2,3)
则打印
|  1 2 3|
|1      |
|2      |
|3   x  |

3.在2的基础上，输入坐标后再输入x或o，在对应位置打印
超出范围提示输入错误
输入的不是x或o,提示错误

4.先打印空棋盘，再重复过程3，每次清屏
超出范围提示输入错误
输入的不是x或o，提示错误
输入的坐标已经有内容了，提示错误
提示：清屏操作如下
#include<windows.h>
system("cls");

5.(meduim)在4的基础上，增加规则判定
先手x后，后手必须是o，否则报错
当横竖斜满足都是x或都是o后，提示x方或o方获胜，程序退出

6.(hard)升级版，在上述基础之上，要求可存储进度和恢复上一次进度

1.打印下列图形

| 1 2 3|

|1 |

|2 |

|3 |

| 1 2 3|

|1 x x x|

|2 x x x|

|3 x x x|

| 1 2 3|

|1 o o o|

|2 o o o|

|3 o o o|

2.在1的基础上，根据输入的坐标(x,y)打印图形

超出范围提示输入错误

例如输入(2,3)

则打印

| 1 2 3|

|1 |

|2 |

|3 x |

3.在2的基础上，输入坐标后再输入x或o，在对应位置打印

超出范围提示输入错误

输入的不是x或o,提示错误

4.先打印空棋盘，再重复过程3，每次清屏

超出范围提示输入错误

输入的不是x或o，提示错误

输入的坐标已经有内容了，提示错误

提示：清屏操作如下

#include<windows.h>

system("cls");

5.(meduim)在4的基础上，增加规则判定

先手x后，后手必须是o，否则报错

当横竖斜满足都是x或都是o后，提示x方或o方获胜，程序退出

6.(hard)升级版，在上述基础之上，要求可存储进度和恢复上一次进度

代码如下，每变动一次重新粘贴一版，方便你们观察变化


#include <stdio.h>
// http://blog.hylstudio.cn/archives/690
// |  1 2 3|
// |1      |
// |2      |
// |3      |

// |  1 2 3|
// |1 x x x|
// |2 x x x|
// |3 x x x|

// |  1 2 3|
// |1 o o o|
// |2 o o o|
// |3 o o o|
int main() {
    printf("|  1 2 3|\n");
    printf("|1      |\n");
    printf("|2      |\n");
    printf("|3      |\n");
    printf("\n");
    
    printf("|  1 2 3|\n");
    printf("|1 x x x|\n");
    printf("|2 x x x|\n");
    printf("|3 x x x|\n");
    printf("\n");

    printf("|  1 2 3|\n");
    printf("|1 o o o|\n");
    printf("|2 o o o|\n");
    printf("|3 o o o|\n");
    printf("\n");

    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/690

// | 1 2 3|

// |1 |

// |2 |

// |3 |

// | 1 2 3|

// |1 x x x|

// |2 x x x|

// |3 x x x|

// | 1 2 3|

// |1 o o o|

// |2 o o o|

// |3 o o o|

int main() {

printf("| 1 2 3|\n");

printf("|1 |\n");

printf("|2 |\n");

printf("|3 |\n");

printf("\n");

printf("| 1 2 3|\n");

printf("|1 x x x|\n");

printf("|2 x x x|\n");

printf("|3 x x x|\n");

printf("\n");

printf("| 1 2 3|\n");

printf("|1 o o o|\n");

printf("|2 o o o|\n");

printf("|3 o o o|\n");

printf("\n");

return 0;

}

第二题


#include <stdio.h>
// http://blog.hylstudio.cn/archives/690
// 在1的基础上，根据输入的坐标(x,y)打印图形
// 超出范围提示输入错误
// 例如输入2,3
// 则打印
// |  1 2 3|
// |1      |
// |2     x|
// |3      |
int main() {
  int row = 1;
  int column = 1;
  int i = 0;
  int j = 0;
  int boardColumns = 3;
  int boardRows = 3;
  int board[][3] = {
      {0, 0, 0},
      {0, 0, 0},
      {0, 0, 0},
  };
  int chess = 0;
  char chessChar = ' ';
  printf("please input position:");
  scanf("%d,%d", &row, &column);
  board[row - 1][column - 1] = -1;
  if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {
    printf("input position error");
    return -1;
  }
  // print chessboard head
  printf("|  1 2 3|\n");
  for (i = 0; i < boardRows; i++) {
    printf("|");
    printf("%d", i + 1);
    for (j = 0; j < boardColumns; j++) {
      chess = board[i][j];
      if (chess == 0) {
        chessChar = ' ';
      } else if (chess == 1) {
        chessChar = 'o';
      } else if (chess == -1) {
        chessChar = 'x';
      }
      printf(" %c", chessChar);
    }
    printf("|\n");
  }
  printf("\n");

  return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/690

// 在1的基础上，根据输入的坐标(x,y)打印图形

// 超出范围提示输入错误

// 例如输入2,3

// 则打印

// | 1 2 3|

// |1 |

// |2 x|

// |3 |

int main() {

int row = 1;

int column = 1;

int i = 0;

int j = 0;

int boardColumns = 3;

int boardRows = 3;

int board[][3] = {

{0, 0, 0},

};

int chess = 0;

char chessChar = ' ';

printf("please input position:");

scanf("%d,%d", &row, &column);

board[row - 1][column - 1] = -1;

if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {

printf("input position error");

return -1;

}

// print chessboard head

printf("| 1 2 3|\n");

for (i = 0; i < boardRows; i++) {

printf("|");

printf("%d", i + 1);

for (j = 0; j < boardColumns; j++) {

chess = board[i][j];

if (chess == 0) {

chessChar = ' ';

} else if (chess == 1) {

chessChar = 'o';

} else if (chess == -1) {

chessChar = 'x';

}

printf(" %c", chessChar);

}

printf("|\n");

}

printf("\n");

return 0;

}

第三题


#include <stdio.h>
// http://blog.hylstudio.cn/archives/690
// 3.在2的基础上，输入坐标后再输入x或o，在对应位置打印
// 超出范围提示输入错误
// 输入的不是x或o,提示错误
int main() {
  int row = 1;
  int column = 1;
  int i = 0;
  int j = 0;
  int boardColumns = 3;
  int boardRows = 3;
  int board[][3] = {
      {0, 0, 0},
      {0, 0, 0},
      {0, 0, 0},
  };
  int chess = 0;
  char chessChar = ' ';

  printf("please input position:");
  scanf("%d,%d", &row, &column);
  if (row < 1 || column < 1 
        || row > boardRows || column > boardColumns) {
    printf("input position error");
    return -1;
  }

  printf("please input chess:");
  scanf("\n%c", &chessChar);//这里多写一个\n是为了处理输入完位置之后的回车键
  if (chessChar == 'x') {
    board[row - 1][column - 1] = -1;
  } else if (chessChar == 'o') {
    board[row - 1][column - 1] = 1;
  } else {
    printf("input chess error");
    return -1;
  }

  // print chessboard head
  printf("|  1 2 3|\n");
  for (i = 0; i < boardRows; i++) {
    printf("|");
    printf("%d", i + 1);
    for (j = 0; j < boardColumns; j++) {
      chess = board[i][j];
      if (chess == 0) {
        chessChar = ' ';
      } else if (chess == 1) {
        chessChar = 'o';
      } else if (chess == -1) {
        chessChar = 'x';
      }
      printf(" %c", chessChar);
    }
    printf("|\n");
  }
  printf("\n");

  return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/690

// 3.在2的基础上，输入坐标后再输入x或o，在对应位置打印

// 超出范围提示输入错误

// 输入的不是x或o,提示错误

int main() {

int row = 1;

int column = 1;

int i = 0;

int j = 0;

int boardColumns = 3;

int boardRows = 3;

int board[][3] = {

{0, 0, 0},

};

int chess = 0;

char chessChar = ' ';

printf("please input position:");

scanf("%d,%d", &row, &column);

if (row < 1 || column < 1

|| row > boardRows || column > boardColumns) {

printf("input position error");

return -1;

}

printf("please input chess:");

scanf("\n%c", &chessChar);//这里多写一个\n是为了处理输入完位置之后的回车键

if (chessChar == 'x') {

board[row - 1][column - 1] = -1;

} else if (chessChar == 'o') {

board[row - 1][column - 1] = 1;

} else {

printf("input chess error");

return -1;

}

// print chessboard head

printf("| 1 2 3|\n");

for (i = 0; i < boardRows; i++) {

printf("|");

printf("%d", i + 1);

for (j = 0; j < boardColumns; j++) {

chess = board[i][j];

if (chess == 0) {

chessChar = ' ';

} else if (chess == 1) {

chessChar = 'o';

} else if (chess == -1) {

chessChar = 'x';

}

printf(" %c", chessChar);

}

printf("|\n");

}

printf("\n");

return 0;

}

第四题


#include <stdio.h>
#include <windows.h>
// 4.先打印空棋盘，再重复过程3，每次清屏
// 超出范围提示输入错误
// 输入的不是x或o，提示错误
// 输入的坐标已经有内容了，提示错误
// 提示：清屏操作如下
// #include<windows.h>
// system("cls");
int main() {
  int row = 1;
  int column = 1;
  int i = 0;
  int j = 0;
  int boardColumns = 3;
  int boardRows = 3;
  int board[][3] = {
      {0, 0, 0},
      {0, 0, 0},
      {0, 0, 0},
  };
  int chess = 0;
  char chessChar = ' ';
  while (1) {
    printf("please input position:");
    scanf("%d,%d", &row, &column);
    if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {
      printf("input position error\n");
      continue;
    }
    if (board[row - 1][column - 1] != 0) {
      printf("input position erro, already has chess\n");
      continue;
    }
    printf("please input chess:");
    scanf("\n%c", &chessChar);  //这里多写一个\n是为了处理输入完位置之后的回车键
    if (chessChar == 'x') {
      board[row - 1][column - 1] = -1;
    } else if (chessChar == 'o') {
      board[row - 1][column - 1] = 1;
    } else {
      printf("input chess error\n");
      continue;
    }
    system("cls");//vscode下debug有问题,需要debug的话暂时去掉这行
    // print chessboard head
    printf("|  1 2 3|\n");
    for (i = 0; i < boardRows; i++) {
      printf("|");
      printf("%d", i + 1);
      for (j = 0; j < boardColumns; j++) {
        chess = board[i][j];
        if (chess == 0) {
          chessChar = ' ';
        } else if (chess == 1) {
          chessChar = 'o';
        } else if (chess == -1) {
          chessChar = 'x';
        }
        printf(" %c", chessChar);
      }
      printf("|\n");
    }
    printf("\n");
  }
  return 0;
}

#include <stdio.h>

#include <windows.h>

// 4.先打印空棋盘，再重复过程3，每次清屏

// 超出范围提示输入错误

// 输入的不是x或o，提示错误

// 输入的坐标已经有内容了，提示错误

// 提示：清屏操作如下

// #include<windows.h>

// system("cls");

int main() {

int row = 1;

int column = 1;

int i = 0;

int j = 0;

int boardColumns = 3;

int boardRows = 3;

int board[][3] = {

{0, 0, 0},

};

int chess = 0;

char chessChar = ' ';

while (1) {

printf("please input position:");

scanf("%d,%d", &row, &column);

if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {

printf("input position error\n");

continue;

}

if (board[row - 1][column - 1] != 0) {

printf("input position erro, already has chess\n");

continue;

}

printf("please input chess:");

scanf("\n%c", &chessChar); //这里多写一个\n是为了处理输入完位置之后的回车键

if (chessChar == 'x') {

board[row - 1][column - 1] = -1;

} else if (chessChar == 'o') {

board[row - 1][column - 1] = 1;

} else {

printf("input chess error\n");

continue;

}

system("cls");//vscode下debug有问题,需要debug的话暂时去掉这行

// print chessboard head

printf("| 1 2 3|\n");

for (i = 0; i < boardRows; i++) {

printf("|");

printf("%d", i + 1);

for (j = 0; j < boardColumns; j++) {

chess = board[i][j];

if (chess == 0) {

chessChar = ' ';

} else if (chess == 1) {

chessChar = 'o';

} else if (chess == -1) {

chessChar = 'x';

}

printf(" %c", chessChar);

}

printf("|\n");

}

printf("\n");

}

return 0;

}

第五题


#include <stdio.h>
#include <windows.h>
// 5.(meduim)在4的基础上，增加规则判定
// 先手x后，后手必须是o，否则报错
// 当横竖斜满足都是x或都是o后，提示x方或o方获胜，程序退出
int main() {
  int row = 1;
  int column = 1;
  int i = 0;
  int j = 0;
  int boardColumns = 3;
  int boardRows = 3;
  int board[][3] = {
      {0, 0, 0},
      {0, 0, 0},
      {0, 0, 0},
  };
  int chess = 0;
  char chessChar = ' ';
  char lastChessChar = ' ';
  int winFlag = 0;
  int firstInput = 1;
  while (1) {
    printf("please input position:");
    scanf("%d,%d", &row, &column);
    getchar();//处理掉回车
    if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {
      printf("input position error\n");
      continue;
    }
    if (board[row - 1][column - 1] != 0) {
      printf("input position erro, already has chess\n");
      continue;
    }
    printf("please input chess:");
    scanf("%c", &chessChar);
    getchar();//处理掉回车
    if ((firstInput == 1 && chessChar == 'x') ||
        (chessChar == 'x' && lastChessChar == 'o')) {
      board[row - 1][column - 1] = -1;
    } else if ((firstInput == 1 && chessChar == 'o') ||
               (chessChar == 'o' && lastChessChar == 'x')) {
      board[row - 1][column - 1] = 1;
    } else {
      printf("input chess error\n");
      continue;
    }
    if (firstInput == 1) {
      firstInput = 0;
    }
    lastChessChar = chessChar;
    system("cls");  // vscode下debug有问题,需要debug的话暂时去掉这行
    // print chessboard head
    printf("|  1 2 3|\n");
    for (i = 0; i < boardRows; i++) {
      printf("|");
      printf("%d", i + 1);
      for (j = 0; j < boardColumns; j++) {
        chess = board[i][j];
        if (chess == 0) {
          chessChar = ' ';
        } else if (chess == 1) {
          chessChar = 'o';
        } else if (chess == -1) {
          chessChar = 'x';
        }
        printf(" %c", chessChar);
      }
      printf("|\n");
    }
    printf("\n");

    //判断规则是否有胜利的
    //按行
    for (i = 0; i < boardRows; i++) {
      winFlag = board[i][0] + board[i][1] + board[i][2];
      if (winFlag == 3) {
        printf("o win");
        return 0;
      } else if (winFlag == -3) {
        printf("x win");
        return 0;
      }
    }
    //按列
    for (j = 0; j < boardColumns; j++) {
      winFlag = board[0][j] + board[1][j] + board[2][j];
      if (winFlag == 3) {
        printf("o win");
        return 0;
      } else if (winFlag == -3) {
        printf("x win");
        return 0;
      }
    }

    //斜着的
    winFlag = board[0][0] + board[1][1] + board[2][2];
    if (winFlag == 3) {
      printf("o win");
      return 0;
    } else if (winFlag == -3) {
      printf("x win");
      return 0;
    }
    winFlag = board[0][0] + board[1][1] + board[2][2];
    if (winFlag == 3) {
      printf("o win");
      return 0;
    } else if (winFlag == -3) {
      printf("x win");
      return 0;
    }
  }
  return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

#include <stdio.h>

#include <windows.h>

// 5.(meduim)在4的基础上，增加规则判定

// 先手x后，后手必须是o，否则报错

// 当横竖斜满足都是x或都是o后，提示x方或o方获胜，程序退出

int main() {

int row = 1;

int column = 1;

int i = 0;

int j = 0;

int boardColumns = 3;

int boardRows = 3;

int board[][3] = {

{0, 0, 0},

};

int chess = 0;

char chessChar = ' ';

char lastChessChar = ' ';

int winFlag = 0;

int firstInput = 1;

while (1) {

printf("please input position:");

scanf("%d,%d", &row, &column);

getchar();//处理掉回车

if (row < 1 || column < 1 || row > boardRows || column > boardColumns) {

printf("input position error\n");

continue;

}

if (board[row - 1][column - 1] != 0) {

printf("input position erro, already has chess\n");

continue;

}

printf("please input chess:");

scanf("%c", &chessChar);

getchar();//处理掉回车

if ((firstInput == 1 && chessChar == 'x') ||

(chessChar == 'x' && lastChessChar == 'o')) {

board[row - 1][column - 1] = -1;

} else if ((firstInput == 1 && chessChar == 'o') ||

(chessChar == 'o' && lastChessChar == 'x')) {

board[row - 1][column - 1] = 1;

} else {

printf("input chess error\n");

continue;

}

if (firstInput == 1) {

firstInput = 0;

}

lastChessChar = chessChar;

system("cls"); // vscode下debug有问题,需要debug的话暂时去掉这行

// print chessboard head

printf("| 1 2 3|\n");

for (i = 0; i < boardRows; i++) {

printf("|");

printf("%d", i + 1);

for (j = 0; j < boardColumns; j++) {

chess = board[i][j];

if (chess == 0) {

chessChar = ' ';

} else if (chess == 1) {

chessChar = 'o';

} else if (chess == -1) {

chessChar = 'x';

}

printf(" %c", chessChar);

}

printf("|\n");

}

printf("\n");

//判断规则是否有胜利的

//按行

for (i = 0; i < boardRows; i++) {

winFlag = board[i][0] + board[i][1] + board[i][2];

if (winFlag == 3) {

printf("o win");

return 0;

} else if (winFlag == -3) {

printf("x win");

return 0;

}

//按列

for (j = 0; j < boardColumns; j++) {

winFlag = board[0][j] + board[1][j] + board[2][j];

if (winFlag == 3) {

printf("o win");

return 0;

} else if (winFlag == -3) {

printf("x win");

return 0;

}

//斜着的

winFlag = board[0][0] + board[1][1] + board[2][2];

if (winFlag == 3) {

printf("o win");

return 0;

} else if (winFlag == -3) {

printf("x win");

return 0;

}

winFlag = board[0][0] + board[1][1] + board[2][2];

if (winFlag == 3) {

printf("o win");

return 0;

} else if (winFlag == -3) {

printf("x win");

return 0;

}

return 0;

}

2019C语言题目2-循环强化

循环强化


1.打印下列图形

|***********|
|***********|
|***********|
|***********|


|*          |
|***        |
|*****      |
|*******    |
|*********  |
|***********|

|***********|
|*********  |
|*******    |
|*****      |
|***        |
|*          |

|          *|
|        ***|
|      *****|
|    *******|
|  *********|
|***********|

|***********|
|  *********|
|    *******|
|      *****|
|        ***|
|          *|

|     *     |
|    ***    |
|   *****   |
|  *******  |
| ********* |
|***********|

1.打印下列图形

|***********|

|* |

|*** |

|***** |

|******* |

|********* |

|***********|

|********* |

|******* |

|***** |

|*** |

|* |

| *|

| ***|

| *****|

| *******|

| *********|

|***********|

| *********|

| *******|

| *****|

| ***|

| *|

| * |

| *** |

| ***** |

| ******* |

| ********* |

|***********|

答案如下


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main(int argc, char const *argv[]) {
    // 1.1 给你找规律的，主要强化循环
    // printf("|***********|\n");
    // printf("|***********|\n");
    // printf("|***********|\n");
    // printf("|***********|\n");

    // 1.2
    int columns = 11;
    int rows = 4;
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++) {  //打印每行
        printf("|");
        for (j = 0; j < columns; j++) {  //打印每列
            printf("*");
        }
        printf("|\n");
    }
    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main(int argc, char const *argv[]) {

// 1.1 给你找规律的，主要强化循环

// printf("|***********|\n");

// 1.2

int columns = 11;

int rows = 4;

int i = 0;

int j = 0;

for (i = 0; i < rows; i++) { //打印每行

printf("|");

for (j = 0; j < columns; j++) { //打印每列

printf("*");

}

printf("|\n");

}

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
// |*          |
// |***        |
// |*****      |
// |*******    |
// |*********  |
// |***********|
int main(int argc, char const *argv[]) {
    int columns = 11;
    int rows = 6;
    int i = 0;
    int j = 0;
    int stars = 0;                // 1 3 5 7 9  => i * 2 + 1
    int space = 0;                // columns - stars
    for (i = 0; i < rows; i++) {  //打印每行
        printf("|");
        for (j = 0; j < i * 2 + 1; j++) {  //打印*
            printf("*");
        }
        for (j = 0; j < columns - (i * 2 + 1); j++) {
            printf(" ");
        }
        printf("|\n");
    }
    printf("下面是骚操作，数学好的人可以看看\n");
    for (i = 0; i < rows; i++) {  //打印每行
        printf("|");
        for (j = 0; j < columns; j++) {
            if (i * 2 >= j) {
                printf("*");
            } else {
                printf(" ");
            }
        }
        printf("|\n");
    }
    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

// |* |

// |*** |

// |***** |

// |******* |

// |********* |

// |***********|

int main(int argc, char const *argv[]) {

int columns = 11;

int rows = 6;

int i = 0;

int j = 0;

int stars = 0; // 1 3 5 7 9 => i * 2 + 1

int space = 0; // columns - stars

for (i = 0; i < rows; i++) { //打印每行

printf("|");

for (j = 0; j < i * 2 + 1; j++) { //打印*

printf("*");

}

for (j = 0; j < columns - (i * 2 + 1); j++) {

printf(" ");

}

printf("|\n");

}

printf("下面是骚操作，数学好的人可以看看\n");

for (i = 0; i < rows; i++) { //打印每行

printf("|");

for (j = 0; j < columns; j++) {

if (i * 2 >= j) {

printf("*");

} else {

printf(" ");

}

printf("|\n");

}

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
// |***********|
// |*********  |
// |*******    |
// |*****      |
// |***        |
// |*          |
int main(int argc, char const *argv[]) {
    int columns = 11;
    int rows = 6;
    int i = 0;
    int j = 0;
    int stars = 0;                // 1 3 5 7 9  => i * 2 + 1
    int space = 0;                // columns - stars
    //解法不唯一，能算对就行
    for (i = rows - 1; i >= 0; i--) {  //打印每行
        printf("|");
        for (j = i * 2 + 1 - 1; j >= 0; j--) {  //打印*
            printf("*");
        }
        for (j = columns - (i * 2 + 1) - 1; j >= 0; j--) {
            printf(" ");
        }
        printf("|\n");
    }
    //一次方程求解同理，懒得写了，自己找找规律
    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

// |***********|

// |********* |

// |******* |

// |***** |

// |*** |

// |* |

int main(int argc, char const *argv[]) {

int columns = 11;

int rows = 6;

int i = 0;

int j = 0;

int stars = 0; // 1 3 5 7 9 => i * 2 + 1

int space = 0; // columns - stars

//解法不唯一，能算对就行

for (i = rows - 1; i >= 0; i--) { //打印每行

printf("|");

for (j = i * 2 + 1 - 1; j >= 0; j--) { //打印*

printf("*");

}

for (j = columns - (i * 2 + 1) - 1; j >= 0; j--) {

printf(" ");

}

printf("|\n");

}

//一次方程求解同理，懒得写了，自己找找规律

return 0;

}

接下来的两个对每列的打印顺序反转下就行

最后一个把前面的空格数除2，分三段打印就行，留给你们自己练习用

2019C语言题目1

题目如下，稍后再更新配套说明，zhanggai说他要写题解，等他的了。或者有哪个同学觉得自己写的好的发给我，我更新


1.打印下列图形

|***********|
|***********|
|***********|
|***********|

2.打印下列图形

|* * * * * *|
| * * * * * |
|* * * * * *|
| * * * * * |

3.在2的基础上，自定义输入字符c，打印
|c c c c c c|
| c c c c c |
|c c c c c c|
| c c c c c |
例如，如果输入a，则打印
|a a a a a a|
| a a a a a |
|a a a a a a|
| a a a a a |

4.在3的基础上，自定义输入行号n(n >= 1),
如果n是奇数
打印|c c c c c c|
如果n是偶数
打印| c c c c c |
如果n是负数
提示输入错误

5.在2的基础上，自定义输入字符c,个数n，行数m
打印奇数行n个c，偶数行n-1个c

1.打印下列图形

|***********|

2.打印下列图形

|* * * * * *|

| * * * * * |

|* * * * * *|

| * * * * * |

3.在2的基础上，自定义输入字符c，打印

|c c c c c c|

| c c c c c |

|c c c c c c|

| c c c c c |

例如，如果输入a，则打印

|a a a a a a|

| a a a a a |

|a a a a a a|

| a a a a a |

4.在3的基础上，自定义输入行号n(n >= 1),

如果n是奇数

打印|c c c c c c|

如果n是偶数

打印| c c c c c |

如果n是负数

提示输入错误

5.在2的基础上，自定义输入字符c,个数n，行数m

打印奇数行n个c，偶数行n-1个c

答案如下


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main() {
    printf("|***********|\n");
    printf("|***********|\n");
    printf("|***********|\n");
    printf("|***********|\n");
    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main() {

printf("|***********|\n");

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main() {
    printf("|* * * * * *|\n");
    printf("| * * * * * |\n");
    printf("|* * * * * *|\n");
    printf("| * * * * * |\n");
    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main() {

printf("|* * * * * *|\n");

printf("| * * * * * |\n");

printf("|* * * * * *|\n");

printf("| * * * * * |\n");

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main() {
    char input = '*';
    scanf("%c", &input);
    printf("|%c %c %c %c %c %c|\n", input, input, input, input, input, input);
    printf("| %c %c %c %c %c |\n", input, input, input, input, input);
    printf("|%c %c %c %c %c %c|\n", input, input, input, input, input, input);
    printf("| %c %c %c %c %c |\n", input, input, input, input, input);

    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main() {

char input = '*';

scanf("%c", &input);

printf("|%c %c %c %c %c %c|\n", input, input, input, input, input, input);

printf("| %c %c %c %c %c |\n", input, input, input, input, input);

printf("|%c %c %c %c %c %c|\n", input, input, input, input, input, input);

printf("| %c %c %c %c %c |\n", input, input, input, input, input);

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main() {
    char input = '*';
    int lineNum = 1;
    //input character
    scanf("%c", &input);
    //input lineNum
    scanf("%d", &lineNum);
    //check lineNum range
    if (lineNum < 1) {
        printf("input n error, n should greater than equal 1!\n");
        return -1;
    }
    if (lineNum % 2 == 1) {
        printf("|%c %c %c %c %c %c|\n", input, input, input, input, input,
               input);
    } else {
        printf("| %c %c %c %c %c |\n", input, input, input, input, input);
    }

    return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main() {

char input = '*';

int lineNum = 1;

//input character

scanf("%c", &input);

//input lineNum

scanf("%d", &lineNum);

//check lineNum range

if (lineNum < 1) {

printf("input n error, n should greater than equal 1!\n");

return -1;

}

if (lineNum % 2 == 1) {

printf("|%c %c %c %c %c %c|\n", input, input, input, input, input,

input);

} else {

printf("| %c %c %c %c %c |\n", input, input, input, input, input);

}

return 0;

}


#include <stdio.h>
// http://blog.hylstudio.cn/archives/686
int main() {
  char input = '*';
  int charPerLine = 6;
  int lineNum = 1;
  int lines = 4;
  // input character
  scanf("%c", &input);
  // input charPerLine
  scanf("%d", &charPerLine);
  // input lines
  scanf("%d", &lines);
  // check lineNum range
  if (charPerLine < 1) {
    printf("input n error, n should greater than equal 1!\n");
    return -1;
  }
  // check lines range
  if (lines <= 0) {
    printf("input m error, n should greater than equal 1!\n");
    return -1;
  }
  for (lineNum = 1; lineNum <= lines; lineNum++) {
    printf("|");
    if (lineNum % 2 == 1) {
      for (int i = 0; i < charPerLine - 1; i++) {
        printf("%c ", input);
      }
      printf("%c", input);
    } else {
      printf(" ", input);
      for (int i = 0; i < charPerLine - 1; i++) {
        printf("%c ", input);
      }
    }
    printf("|\n");
  }

  return 0;
}

#include <stdio.h>

// http://blog.hylstudio.cn/archives/686

int main() {

char input = '*';

int charPerLine = 6;

int lineNum = 1;

int lines = 4;

// input character

scanf("%c", &input);

// input charPerLine

scanf("%d", &charPerLine);

// input lines

scanf("%d", &lines);

// check lineNum range

if (charPerLine < 1) {

printf("input n error, n should greater than equal 1!\n");

return -1;

}

// check lines range

if (lines <= 0) {

printf("input m error, n should greater than equal 1!\n");

return -1;

}

for (lineNum = 1; lineNum <= lines; lineNum++) {

printf("|");

if (lineNum % 2 == 1) {

for (int i = 0; i < charPerLine - 1; i++) {

printf("%c ", input);

}

printf("%c", input);

} else {

printf(" ", input);

for (int i = 0; i < charPerLine - 1; i++) {

printf("%c ", input);

}

printf("|\n");

}

return 0;

}

C基础系列教程11——常见错误总结

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=
在这里总结一些初学者常见错误，建议在考试前看一遍。


//从头写起吧，在最开始的预处理语句。
//———————————————————————–
//正确形式：
#include<stdio.h>
#include"stdio.h"
#include<math.h>
#include<math.h>
//错误形式：
//1.拼写错误
#includ<stdio.h>
include<studio.h>
//2.忘记加入要使用的头文件。比如math.h或者string.h
//注意：之后代码之前都没有写头文件
//———————————————————————–
//正确形式：
int main() {
	return 0;
}
//错误形式：
//1.拼写错误
int mian() {
	retrun 0;
}
//2.缺少必要的空格或分号
intmian() {
	retrun 0;
}
//3.括号不成对出现(一个单独的括号会很伤心的~)
int mian() {
	retrun 0;
	//———————————————————————- –
	//正确形式：
	int a, b, c;
	int a = 0, b = 0, c = 0;
	int a[50];
	int a[50] = { 0 };
	double t;
	double t = 0;
	char c = 'a';
	char *s = "abcdefg";
	//错误形式：
	//1.符号使用错误，编写过程不易察觉。。
	int a; b; c;
	int a = 0; b = 0, c = 0;
	char c = "a";
	char *s = 'abcdefg';
	//2.定义数组使用变量
	int i = 50;
	int a[i];
	//———————————————————————- –
	//正确形式：
	int main() {
		int *a = NULL;
		int b = 0;
		a = &b;
		return 0;
	}
	//错误形式：
	//1.星号使用错误，切记指针的定义和调用之间的不同
	int main() {
		int *a;
		int b = 0;
		*a = &b;
		return 0;
	}
	//2.野指针的初始化, NULL必须大写
	int main() {
		int *a = null;
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int main() {
		int a = 1;
		double b = 2.1;
		char c = 'a';
		char *s = "abcdefg";
		int *p = NULL;
		p = &a;
		printf("%d", a);
		printf("%d", *p);
		printf("%.2f", b);
		printf("%c", c);
		printf("%c", *s);
		printf("%s", s);
		printf("%p", p);
		scanf("%d", &a);
		scanf("%lf", &b);
		scanf("%c", &c);
		scanf("%s", s);
		return 0;
	}
	//错误形式：
	//1.格式化文本中的类型与变量类型或数量对应错误
	//可以通过编译，但结果可能与预期结果不一致
	int main() {
		int a = 1;
		double b = 2.1;
		char c = 'a';
		char *s = "abcdefg";
		int *p = NULL;
		p = &a;
		printf("%c", a);
		printf("%*.*f", 3, b);
		scanf("%lf", &a);
		return 0;
	}
	//2.scanf不加或多加取址符&
	int main() {
		int a = 1;
		int *p = NULL;
		p = &a;
		scanf("%d", a);
		scanf("%d", &p);
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a == b) {
			//do something
		} else if (b <= c) {
			//do something
		} else if (c >= a && c <= b) {
			//do something
		} else {
			//do something
		}
		return 0;
	}
	//错误形式：
	//1.逻辑运算符号错误, 引起程序逻辑分支出现问题，得不到正确结果
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a = b) {
			//do something
		} else if (b <= c) {
			//do something
		} else if (a <= c <= b) {//注意！这种写法是错的！！
								 //do something
		} else {
			//do something
		}
		return 0;
	}
	//2.if else 级联写法错误，导致编译失败或者程序逻辑错误
	//可能出现多余大括号，多余分号。缺少空格，或缺少分号
	int main() {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c);
		if (a == b) {
			//do something
		}elseif(b <= c) {
			//do something
		} else if (c >= a && c <= b);
		{
			//do something
		} else {
			//do something
		};
		return 0;
	}
	//———————————————————————- –
	//正确形式：
	int add(int x, int y);
	int padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(a, b));
		printf("%d\n", padd(&a, &b));
		printf("%d\n", padd(pa, pb));
		return 0;
	}
	int add(int x, int y) {
		return x + y;
	}
	int padd(int *x, int *y) {
		return *x + *y;
	}
	//错误形式：
	//1.参数传递类型错误。
	int add(int x, int y);
	int padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(&a, &b));
		printf("%d\n", padd(a, b));
		printf("%d\n", padd(&pa, &pb));
		return 0;
	}
	int add(int x, int y) {
		return x + y;
	}
	int padd(int *x, int *y) {
		return *x + *y;
	}
	//2.声明形式和实际形式不符
	void add(int *x, int y);
	double padd(int *x, int *y);
	int main() {
		int a = 1, b = 2;
		int *pa, *pb;
		pa = &a;
		pb = &b;
		printf("%d\n", add(a, b));
		printf("%d\n", padd(&a, &b));
		printf("%d\n", padd(pa, pb));
		return 0;
	}
	float add(int x, int y) {
		return x + y;
	}
	void padd(int *x, int *y) {
		return *x + *y;
	}
	//———————————————————————-
	//通过考试不是目的，提高自己的程序编写能力才是重要的~
	//如果你看到了这里，感谢你的耐心！
	//记的，细节决定成败。。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

//从头写起吧，在最开始的预处理语句。

//———————————————————————–

//正确形式：

#include<stdio.h>

#include"stdio.h"

#include<math.h>

//错误形式：

//1.拼写错误

#includ<stdio.h>

include<studio.h>

//2.忘记加入要使用的头文件。比如math.h或者string.h

//注意：之后代码之前都没有写头文件

//———————————————————————–

//正确形式：

int main() {

return 0;

}

//错误形式：

//1.拼写错误

int mian() {

retrun 0;

}

//2.缺少必要的空格或分号

intmian() {

retrun 0;

}

//3.括号不成对出现(一个单独的括号会很伤心的~)

int mian() {

retrun 0;

//———————————————————————- –

//正确形式：

int a, b, c;

int a = 0, b = 0, c = 0;

int a[50];

int a[50] = { 0 };

double t;

double t = 0;

char c = 'a';

char *s = "abcdefg";

//错误形式：

//1.符号使用错误，编写过程不易察觉。。

int a; b; c;

int a = 0; b = 0, c = 0;

char c = "a";

char *s = 'abcdefg';

//2.定义数组使用变量

int i = 50;

int a[i];

//———————————————————————- –

//正确形式：

int main() {

int *a = NULL;

int b = 0;

a = &b;

return 0;

}

//错误形式：

//1.星号使用错误，切记指针的定义和调用之间的不同

int main() {

int *a;

int b = 0;

*a = &b;

return 0;

}

//2.野指针的初始化, NULL必须大写

int main() {

int *a = null;

return 0;

}

//———————————————————————- –

//正确形式：

int main() {

int a = 1;

double b = 2.1;

char c = 'a';

char *s = "abcdefg";

int *p = NULL;

p = &a;

printf("%d", a);

printf("%d", *p);

printf("%.2f", b);

printf("%c", c);

printf("%c", *s);

printf("%s", s);

printf("%p", p);

scanf("%d", &a);

scanf("%lf", &b);

scanf("%c", &c);

scanf("%s", s);

return 0;

}

//错误形式：

//1.格式化文本中的类型与变量类型或数量对应错误

//可以通过编译，但结果可能与预期结果不一致

int main() {

int a = 1;

double b = 2.1;

char c = 'a';

char *s = "abcdefg";

int *p = NULL;

p = &a;

printf("%c", a);

printf("%*.*f", 3, b);

scanf("%lf", &a);

return 0;

}

//2.scanf不加或多加取址符&

int main() {

int a = 1;

int *p = NULL;

p = &a;

scanf("%d", a);

scanf("%d", &p);

return 0;

}

//———————————————————————- –

//正确形式：

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a == b) {

//do something

} else if (b <= c) {

//do something

} else if (c >= a && c <= b) {

//do something

} else {

//do something

}

return 0;

}

//错误形式：

//1.逻辑运算符号错误, 引起程序逻辑分支出现问题，得不到正确结果

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a = b) {

//do something

} else if (b <= c) {

//do something

} else if (a <= c <= b) {//注意！这种写法是错的！！

//do something

} else {

//do something

}

return 0;

}

//2.if else 级联写法错误，导致编译失败或者程序逻辑错误

//可能出现多余大括号，多余分号。缺少空格，或缺少分号

int main() {

int a, b, c;

scanf("%d %d %d", &a, &b, &c);

if (a == b) {

//do something

}elseif(b <= c) {

//do something

} else if (c >= a && c <= b);

{

//do something

} else {

//do something

};

return 0;

}

//———————————————————————- –

//正确形式：

int add(int x, int y);

int padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(a, b));

printf("%d\n", padd(&a, &b));

printf("%d\n", padd(pa, pb));

return 0;

}

int add(int x, int y) {

return x + y;

}

int padd(int *x, int *y) {

return *x + *y;

}

//错误形式：

//1.参数传递类型错误。

int add(int x, int y);

int padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(&a, &b));

printf("%d\n", padd(a, b));

printf("%d\n", padd(&pa, &pb));

return 0;

}

int add(int x, int y) {

return x + y;

}

int padd(int *x, int *y) {

return *x + *y;

}

//2.声明形式和实际形式不符

void add(int *x, int y);

double padd(int *x, int *y);

int main() {

int a = 1, b = 2;

int *pa, *pb;

pa = &a;

pb = &b;

printf("%d\n", add(a, b));

printf("%d\n", padd(&a, &b));

printf("%d\n", padd(pa, pb));

return 0;

}

float add(int x, int y) {

return x + y;

}

void padd(int *x, int *y) {

return *x + *y;

}

//———————————————————————-

//通过考试不是目的，提高自己的程序编写能力才是重要的~

//如果你看到了这里，感谢你的耐心！

//记的，细节决定成败。。

C基础系列教程导航

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe/）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=

如果链接不生效，请自行复制地址访问

计算机系列网课
http://study.163.com/curricula/cs.htm

翁恺 —— C语言程序设计
http://mooc.study.163.com/course/1000002011?tid=2001530003#/info

浙江大学基础练习网站
http://pta.patest.cn/pta/test/14/exam/4

C基础系列教程基本内容更新完毕，后期会逐步添加练习题和课后习题=-=
张浩然博客
https://zhr.moe

C基础系列教程1——基础数据类型以及输入输出语句

C基础系列教程1——基础数据类型以及输入输出语句

C基础系列教程2——逻辑表达式和判断语句

C基础系列教程2——逻辑表达式和判断语句

C基础系列教程3——switch和数组基础

C基础系列教程3——switch和数组基础

C基础系列教程4——简单循环

C基础系列教程4——简单循环

C基础系列教程5——多重循环

C基础系列教程5——多重循环

循环练习题2 HDOJ 2010
http://acm.hdu.edu.cn/showproblem.php?pid=2010

C基础系列教程6——函数

C基础系列教程6——函数

C基础系列教程7——指针1

C基础系列教程7——指针1

C基础系列教程8——指针2

C基础系列教程8——指针2

C基础系列教程9——指针3

C基础系列教程9——指针3

C基础系列教程10——结构体

C基础系列教程10——结构体

C基础系列教程11——常见错误总结

C基础系列教程11——常见错误总结

C基础系列教程10——结构体

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=
如果你觉得进度太快，可以等你熟悉了前面的内容后再继续往下看

先思考一个问题：
（亲爱的小明出场）假如一个小组有10个同学，需要记录在程序中，其中几个同学分别叫小明、小红、小绿、小然、小琪、小玮、小霄·········（这些只是随便起的名字，臻的是随便起的233333）
现在需要分别记录TA们的编号、身高、体重什么的，为了方便写代码所以只出现数字，都是int，应该不会有越界情况发生（逃）。请思考如何声明变量。
先想想，再往下看
————————— 我是萌萌哒分割线 ●▽● —————————
你可能写出这样的代码（这是个错误的示范）


int xiaomingdeid;
int xiaomingdeshengao;
int xiaomingdetizhong;
int xiaoludeid;
int xiaoludeshengao;
int xiaoludetizhong;

int xiaomingdeid;

int xiaomingdeshengao;

int xiaomingdetizhong;

int xiaoludeid;

int xiaoludeshengao;

int xiaoludetizhong;

每个人的每个数据（以后可以称之为属性）都声明一个变量。这样当然是可以的（如果你不嫌累）。
顺便一说，变量的命名要简洁明了，不要这么啰嗦=-=并且不要用拼音。

不多嘛，30行就写完了。然后呢，等你写完之后突然有人又告诉你（客户改需求了），需要每个人再增加一个年龄。。你内心一定是这样的
————————— 我是萌萌哒分割线 ●▽● —————————
现在遇到的问题就是这样，今天介绍一个新的东西，struct。叫做结构体，一个结构体可以包括多个变量，定义方式如下。
你需要新建一个文件，文件名叫做person.h，这种后缀的文件我们称作头文件，内容是这样的


#ifndef _person_h
#define _person_h
struct person {
	int id;
	int height;
	int weight;
};
#endif

#ifndef _person_h

#define _person_h

struct person {

int id;

int height;

int weight;

};

#endif

这样就定义了1个结构体类型叫做person，注意不要丢了右大括号后面的那个分号。在主程序中我们需要在#include<stdio.h>的后面加一行 #include “person.h” ，这种自己写的头文件我们用双引号引起来以便于和C自带的头文件混淆。

接下来就可以定义变量了，代码是这样的。


int main() {
	struct person xiaoming;
	struct person xiaohong;
	xiaoming.id = 0;
	xiaoming.height = 180;
	xiaoming.weight = 150;
	xiaohong.id = 1;
	xiaohong.height = 160;
	xiaohong.weight = xiaoming.weight;
	system("pause");
	return 0;
}

int main() {

struct person xiaoming;

struct person xiaohong;

xiaoming.id = 0;

xiaoming.height = 180;

xiaoming.weight = 150;

xiaohong.id = 1;

xiaohong.height = 160;

xiaohong.weight = xiaoming.weight;

system("pause");

return 0;

}

第一行声明了一个叫做xiaoming的变量，这是个特殊的变量，因为它是个结构体，里面包含了刚刚定义的三个属性，id、身高、体重。我们使用.（这是一个点儿）来访问结构体变量中的属性给它赋值（当然也可以读取，比如最后一行）。

这样的话定义起来就会方便很多，增加属性的话直接去更改头文件的定义就好了。

————————— 我是萌萌哒分割线 ●▽● —————————
接下来会出现一个问题，你每次定义的时候都要敲一个struct person，这令人十分讨厌（主要还是懒）。所以呢，我们在把头文件改成这样


#ifndef _person_h
#define _person_h
struct _person {
	int id;
	int height;
	int weight;
};
typedef struct _person person;
#endif

#ifndef _person_h

#define _person_h

struct _person {

int id;

int height;

int weight;

};

typedef struct _person person;

#endif

我把原来的struct person改成了struct _person，加了一个下划线，是为了下面这样做，typedef的意思是定义一个新的类型，把struct _person 叫做person，也就是说你待会输入person就相当于输入了struct _person，这样就少写了一个单词（我臻是太懒了=-=）
那么这样做之后你会发现原来的程序报错了，因为我们加了个下划线，所以源程序有两种改法
第一种，跟着加下划线，这种方法显然更麻烦
第二种，直接删掉struct，这也是我们这样做的目的（其实还是为了偷懒）。

更改后代码如下，小红就删了啊=-=


int main() {
	person xiaoming; xiaoming.id = 0;
	xiaoming.height = 180;
	xiaoming.weight = 150; 
        printf("xiaoming.id = %d\n", xiaoming.id);
	printf("xiaoming.height = %d\n", xiaoming.height);
	printf("xiaoming.weight = %d\n\n", xiaoming.weight); 
	system("pause");
	return 0;
}

int main() {

person xiaoming; xiaoming.id = 0;

xiaoming.height = 180;

xiaoming.weight = 150;

printf("xiaoming.id = %d\n", xiaoming.id);

printf("xiaoming.height = %d\n", xiaoming.height);

printf("xiaoming.weight = %d\n\n", xiaoming.weight);

system("pause");

return 0;

}

————————— 我是萌萌哒分割线 ●▽● —————————
今天有时间，就接着往下写吧=-=一次看不完可以下次接着看

在数据结构中，不光要储存数据，还要对应数据的一些操作，这些操作的集合我们叫做操作集，也就是一堆函数。
所以，在数据结构中很少通过定义一个本地的变量来操作，都是通过函数来进行的，那么这里就有一个问题，在函数中对本地变量操作无法直接传参数，需要传地址，也就是指针。

所以需要更改声明为


//person xiaoming;
//person* addressOfxiaoming;
person* xiaoming = NULL;

//person xiaoming;

//person* addressOfxiaoming;

person* xiaoming = NULL;

第一行是原来的声明，需要改写成第二行的样子，之所以注释掉是因为太长（虽然更好理解，也就是小明所在内存中的地址），所以依然叫做xiaoming（还是太懒），现在你要注意，接下来的 “xiaoming” 的意思是小明所在的地址，不再是之前的xiaoming了。还有一点要注意，指针的声明要初始化为NULL，否则叫做野指针，不知道指向哪里。

我们来写一个函数来进行和之前同样的操作。主程序是这样的，注意多加了一个stdlib.h


#include <stdio.h>
#include <stdlib.h>
#include "person.h"
int main() {
	person* xiaoming; xiaoming = (person *)malloc(sizeof(person));
	fun(xiaoming); system("pause");
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include "person.h"

int main() {

person* xiaoming; xiaoming = (person *)malloc(sizeof(person));

fun(xiaoming); system("pause");

return 0;

}

其中需要解释的是malloc这一行，意思是分配一块大小刚好能放得下person结构体的内存，这时候电脑并不知道这块内存要放什么，你需要强制类型转换成person指针类型来告诉电脑这里要放的是一个person。其中sizeof求出的是一个person占多大的内存，malloc负责向系统申请一块这么大的内存，然后返回一个内存的地址，但是是不知道类型的地址（也就是void *），最后强制转换成person*
这样的做法就相当于之前的person xiaoming;然后把小明的地址记下来。最后一行把小明的地址传给fun函数处理。

接下来写fun函数，我们接收到的是person的指针，叫做sb（somebody-_-||不要多想），这个sb就是一个指向了person的指针。


void fun(person * sb) { //这的意思是somebody-_-||不要多想
	(*sb).id = 0;
	(*sb).height = 180;
	(*sb).weight = 150;
	printf("xiaoming.id = %d\n", (*sb).id);
	printf("xiaoming.height = %d\n", (*sb).height);
	printf("xiaoming.weight = %d\n\n", (*sb).weight);
}

void fun(person * sb) { //这的意思是somebody-_-||不要多想

(*sb).id = 0;

(*sb).height = 180;

(*sb).weight = 150;

printf("xiaoming.id = %d\n", (*sb).id);

printf("xiaoming.height = %d\n", (*sb).height);

printf("xiaoming.weight = %d\n\n", (*sb).weight);

}

我们的做法和之前的整数交换差不多，*sb代表的是间接取出sb指向的内容，也就是小明，之后在用.（这是一个点儿）来访问小明的id、身高、体重。之所以加括号是因为那个“点”的运算优先级要高于间接取值的星号。
但是人总是懒的=-=又要打括号星号还有点太麻烦了→_→所以呢就有这这种写法，和上面完全等价


void fun(person * sb) { //这的意思是somebody-_-||不要多想
	sb->id = 0;
	sb->height = 180;
	sb->weight = 150;
	printf("xiaoming.id = %d\n", sb->id);
	printf("xiaoming.height = %d\n", sb->height);
	printf("xiaoming.weight = %d\n\n", sb->weight);
}

void fun(person * sb) { //这的意思是somebody-_-||不要多想

sb->id = 0;

sb->height = 180;

sb->weight = 150;

printf("xiaoming.id = %d\n", sb->id);

printf("xiaoming.height = %d\n", sb->height);

printf("xiaoming.weight = %d\n\n", sb->weight);

}

是的你没看错就是一个箭头，一个减号和一个大于号。
注意这俩符号中间不能加空格
注意这俩符号中间不能加空格
注意这俩符号中间不能加空格
重要的事情说三遍。

————————— 我是萌萌哒分割线 ●▽● —————————
补充说明：.(这是一个点)运算用在访问一个结构体变量的属性时，那个箭头用于指针指向的结构体属性时候，一个是直接访问一个是间接访问，后续还可能会出现结构体的属性指向结构体，就可能出现先箭头再一个点来访问，比如链表。。。这是小然提出来的补充哦（逃
————————— 我是萌萌哒分割线 ●▽● —————————
至此，数据结构基础告一段落，如果还有补充的我会继续发=-=
下面是我的github，这里有一些数据结构的源码。。。还在学习ing=-=（请勿抄袭！请勿抄袭！请勿抄袭！）

https://github.com/956237586/DataStructure-C/tree/master/DataStructure-C
————————— 我是萌萌哒分割线 ●▽● —————————
题外话，关于箭头还有个黑魔法，依然转自知乎 http://www.zhihu.com/question/27417946

C基础系列教程9——指针3

当你在C中需要储存大量的数据的时候，最常见的一种做法就是数组，今天将介绍数组和指针之间的关系，展示数组真实的模样。

本次主要为一维数组，多维数组就是一维数组的推广而已，可以仿照本文方法分析研究。

首先编写测试代码如下


int arr[5] = { 0 };
int *pa = &arr;
int i;
for (i = 0; i < 5; i++) {
	arr[i] = i;
}

int arr[5] = { 0 };

int *pa = &arr;

int i;

for (i = 0; i < 5; i++) {

arr[i] = i;

}

在这段程序中定义了一个整数数组，一个整数指针变量
断点调试观察内存的状态是这样的

这是整个数组，图中每个红框就是一个int，是数组中的一个单元，从下往上看，可以发现分别就是arr[4]一直到a[0]
————————我是萌萌哒分割线 ●▽●——————

这是指针pa
————————我是萌萌哒分割线 ●▽●——————
在接下来为了节省地方，我会把四个字节的内容放到一行，省略一些地址的显示，如下图

————————我是萌萌哒分割线 ●▽●——————

这两张和之前的两张意思是一样的，只是省略了部分地址的显示，便于观察，看的时候从下向上，从右至左
————————我是萌萌哒分割线 ●▽●——————

观察上图不难发现，取数组的地址的结果就是数组最开始的地址，指针也指向这个位置。继续增加代码如下


#include <stdio.h>
int main() {
	int arr[5] = { 0 };
	int *pa = &arr;
	int i;

	for (i = 0; i < 5; i++) {
		arr[i] = i;
	}

	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr[0] = %d\n", arr[0]);

	printf("pa = %p\n", pa);
	printf("*pa = %d\n", *pa);

	printf("&arr[2] = %p\n", &arr[2]);
	printf("arr[2] = %d\n", arr[2]);

	printf("pa + 2 = %p\n", pa + 2);
	printf("*(pa + 2) = %d\n", *(pa + 2));

	system("pause");
	return 0;
}

#include <stdio.h>

int main() {

int arr[5] = { 0 };

int *pa = &arr;

int i;

for (i = 0; i < 5; i++) {

arr[i] = i;

}

printf("arr = %p\n", arr);

printf("&arr[0] = %p\n", &arr[0]);

printf("arr[0] = %d\n", arr[0]);

printf("pa = %p\n", pa);

printf("*pa = %d\n", *pa);

printf("&arr[2] = %p\n", &arr[2]);

printf("arr[2] = %d\n", arr[2]);

printf("pa + 2 = %p\n", pa + 2);

printf("*(pa + 2) = %d\n", *(pa + 2));

system("pause");

return 0;

}

运行结果如图

让我们来一行一行的分析
第1行、第2行、第4行，如果我们尝试直接打印数组名字，会发现打印出来的就会和数组第一个元素的结果是一样的，和指针的内容也是一样的，这说明，数组的名字就代表了数组的首元素地址。指针指向数组的时候也会指向这个数组的首元素地址。

当然，打印出来的arr[0]也肯定会和*pa一样，因为pa的值就是第一个元素的地址。这没什么好解释的，自习对照上面的内存截图很容易就能看出来。

接下来我拿第3个元素作为例子，也就是arr[2]，剩下的几行你会发现，pa + 2 我们称作指针的偏移，偏移2个单位，由于一个整数占4个字节也就是四个格子，所以也就偏移到了数组中的第3个数字，你可以把2改成其他值观察结果是怎样的，最后的结果你会发现实际上arr[2]的含义可以理解为从数组首地址也就是arr先偏移2再取值，也就是最后一行写的那样。

（题外话，这里还有个黑魔法，转自知乎）

如果你明白了刚才说的数组，那么这个黑魔法的原理你也一定能很快的想明白，这个就留给大家思考吧=-=
温馨提示，你可以编写一些代码验证这个黑魔法，断点调试观察内存，尝试更换等价表达式来验证你的猜想是否正确

下次介绍struct的基本使用