我是初学者，请解答一下（c语言）

int main（）执行后，不是会产生一个整数函数值，那为啥在int main的框架下，里面可以进行其他类型，例如浮点型的运算
ps 问题可能有点蠢，但作为初学者啥都想问一下，各位请多多包涵

int main()表示需要return 一个整型值，至于main函数里面要做什么运算，和函数名定义没关系。
如果解决你的问题，点赞采纳，谢谢！

【相关推荐】

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/1008556
• 我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：【C语言】写一函数，求一个字符串的长度。在main函数中输入字符串，并输出其长度。
• 您还可以看一下 王健伟老师的C语言入门篇课程中的 指针数组、指针的指针、main函数参数、小结小节, 巩固相关知识点
  
• 除此之外, 这篇博客: C语言链表相关操作中的 所有代码，包括main函数中的测试方法，复制粘贴可直接运行 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

  #include <stdio.h>
  #include <stdlib.h>
  typedef struct Node{
      int data;                                           //数据域
      struct Node *next;                                  //指针域
  }Node,*List;                                            //List代表链表，Node代表一个结点
  
  /*******************************************************************************
   *                                  方法定义区                                   *
   *******************************************************************************/
  Node* CreateNode(int data);                             //创建结点
  List Init();                                            //链表初始化
  void InsertByTail(List L,int data);                     //尾插法插入一个元素
  void InsertByHead(List L,int data);                     //头插法插入一个元素
  void InsertByIndex(List L,int data,int index);          //按照下标插入一个元素
  void PrintList(List L);                                 //打印链表
  void DeleteNodeByIndex(List L,int index);               //通过下标删除元素
  int SelectByIndex(List L,int index);                    //通过下标查询元素
  void UpdateByIndex(List L,int data,int index);          //通过下标更改元素
  int ListSize(List L);                                   //统计有多少个元素，不包含头结点
  Node* FindByIndex(List L,int index);                    //找到下标前的一个元素，返回其地址
  List ReversePrintList(List L);                          //逆序输出链表
  List ReverseList(List L);                               //反转链表
  List LinkTwoListByOrder(List L1,List L2,int type);      //合成两个有序链表（type1升序，type0降序）
  List CreateListBySize(int size);                        //创建对应大小的链表，size不包含头结点
  void DeleteByHead(List L);                              //删除一个链表的尾节点
  void DeleteByTail(List L);                              //删除一个链表的第一个节点（不是删除头结点）
  void DeleteByValue(List L,int value);                   //按照值删除所有节点
  int SelectByIndexReverse(List L,int index);             //查找倒数第i个结点，只能遍历一次
  void DeleteByIndexReverse(List L,int index);            //删除倒数第i个结点，只能遍历一次
  int main(){
      List L = Init();  //初始化
      int i,index,num;
      //创建一个链表，元素为 1 2 3 4 5 6 7 8 9 10
  
      for(i=1;i<10;i=i+2){
          InsertByTail(L,i);
          //InsertByHead(L,i);
      }
      InsertByTail(L,9);
  
      printf("原来的链表为：");
      PrintList(L);  //打印
  
  //    //按下标删除
  //    printf("请输入要删除第几个元素:\n");
  //    scanf("%d",&index);
  //    DeleteNodeByIndex(L,index);
  //    printf("删除第%d个元素后为：",index);
  //    PrintList(L);  //打印
  //
  //    //按下标插入
  //    printf("请输入要插入的下标:\n");
  //    scanf("%d",&index);
  //    printf("请输入要插入的数据:\n");
  //    scanf("%d",&num);
  //    InsertByIndex(L,num,index);
  //    printf("在第%d个位置插入%d后为：\n",index,num);
  //    PrintList(L);  //打印
  //
  //    //按下标查找
  //    printf("请输入要查找的下标:\n");
  //    scanf("%d",&index);
  //    printf("%d对应的数据为：%d\n",index,SelectByIndex(L,index));
  //
  //    //按下标更新
  //    printf("请输入要更新的下标:\n");
  //    scanf("%d",&index);
  //    printf("请输入要更新的值:\n");
  //    scanf("%d",&num);
  //    UpdateByIndex(L,num,index);
  //    printf("更新后的数据为：\n");
  //    PrintList(L);
  //
  //    //逆序输出
  //    printf("逆序输出后为：\n");
  //    ReversePrintList(L->next);
  //
  //    //逆转链表
  //    List new = ReverseList(L);
  //    printf("逆转后为：");
  //    PrintList(new);
  //
  //    //两表连接
  //    List L2 = Init();
  //    for(i=2;i<7;i=i+2){
  //        InsertByTail(L2,i);
  //    }
  //    printf("链表L2:");
  //    PrintList(L2);
  //    List L3 = LinkTwoListByOrder(L,L2,0);
  //    printf("合并后链表L3:");
  //    PrintList(L3);
  
  //    //头删法
  //    DeleteByHead(L);
  //    printf("删除之后的链表为：");
  //    PrintList(L);
  //
  //    //尾删法
  //    DeleteByTail(L);
  //    printf("删除之后的链表为：");
  //    PrintList(L);
  //
  //    //按照元素值删除
  //    DeleteByValue(L,9);
  //    printf("删除之后的链表为：");
  //    PrintList(L);
  
  //    //查找第倒数多少位
  //    index = 2;
  //    int n = SelectByIndexReverse(L,index);
  //    printf("倒数第%d位是：%d\n",index,n);
  //    return 0;
  
      //删除第倒数多少位
      index = 4;
      DeleteByIndexReverse(L,index);
      printf("删除倒数第%d位后：",index);
      PrintList(L);
      return 0;
  
  }
  void InsertByTail(List L,int data){
      Node *p, *node = CreateNode(data); //创建新结点
      p = L;
      node->data = data;
      node->next = NULL;
      while (p->next) //找到最后一个结点
      {
          // p++; 千万不要写p++啊，害死人不偿命！！！
          p = p -> next;
      }
      p->next = node;
  }
  Node* CreateNode(int data){     //创建结点
      Node* node = (Node*)malloc(sizeof(Node));
      node->data = data;
      return node;
  }
  List Init(){           //初始化链表
      return CreateNode(0); //头指针
  }
  void PrintList(List L){
      Node* p = L->next;
      while (p != NULL){
          printf("%d ",p->data);
          p = p -> next;
      }
      printf("\n");
  }
  void InsertByHead(List L,int data){  //头插法
      Node *node = CreateNode(data);  //创建结点
      node->next = L->next;
      L->next = node;
  }
  void DeleteNodeByIndex(List L,int index){
      Node *temp;
      Node* p = FindByIndex(L,index); //找到index的前一个结点
      if(index > ListSize(L) || index < 1){  //下标有误
          return ;
      }
      // 删除结点
      temp = p->next;
      p->next = p->next->next;
      free(temp);
  }
  int ListSize(List L){
      int i = 0;
      Node* p = L->next;
      while (p != NULL){
          i++;
          p = p-> next;
      }
      return i;
  }
  Node* FindByIndex(List L,int index){
      int i;
      Node* p = L;
      for (i = 1; i < index; i++) { //找到index的前一个结点
          p = p -> next;
      }
      return p;
  }
  void InsertByIndex(List L,int data,int index){
      Node* p = FindByIndex(L,index);
      //创建结点
      Node* node = CreateNode(data);
      //开始插入
      node->next = p->next;
      p->next = node;
  }
  int SelectByIndex(List L,int index){
      Node* p = FindByIndex(L,index);
      return p->next->data;
  }
  void UpdateByIndex(List L,int data,int index){
      Node* p = FindByIndex(L,index);
      p->next->data = data;
  }
  List ReversePrintList(List L){
      //顺序输出很简单，逆序输出可以用递归
      if(L == NULL) return NULL;
      ReversePrintList(L->next);
      printf("%d ",L->data);
  }
  List ReverseList(List L){
      List now = Init();  //创建一个链表
      Node* p = L->next;
      while (p!=NULL){ //遍历L链表
          InsertByHead(now,p->data);  //用头插法插入新链表
          p = p->next;
      }
      return now;
  }
  List LinkTwoListByOrder(List L1,List L2,int type){
      int index = 0,i,j,temp,a[ListSize(L1)+ ListSize(L2)];
      List L = Init();
      Node *p1 = L1 -> next,*p2 = L2 -> next;
      // 将两个链表的数据放到数组中
      while (p1!=NULL){
          a[index] = p1->data;
          p1 = p1->next;
          index++;
      }
      while (p2!=NULL){
          a[index] = p2->data;
          p2 = p2->next;
          index++;
      }
      //对数组进行升序排序
      if(type == 1){
          for(i=0;i<index;i++){
              for(j=0;j<index-i-1;j++){
                  if(a[j] > a[j+1]){
                      temp = a[j];
                      a[j] = a[j+1];
                      a[j+1] = temp;
                  }
              }
          }
      }else if(type == 0){ //降序
          for(i=0;i<index;i++){
              for(j=0;j<index-i-1;j++){
                  if(a[j] < a[j+1]){
                      temp = a[j];
                      a[j] = a[j+1];
                      a[j+1] = temp;
                  }
              }
          }
      }
      //将数组转到链表中
      p1 = L;
      for(i=0;i<index;i++) {
          //新建节点
          Node* node = CreateNode(a[i]);
          p1 -> next = node;
          p1 = node;
      }
      return L;
  }
  List CreateListBySize(int size){
      int i;
      List L = Init();
      for (i=0;i<size;i++){
          InsertByHead(L,0);
      }
      return L;
  }
  void DeleteByHead(List L){
      Node* temp = L->next;
      L->next = temp -> next;
      free(temp);
  }
  void DeleteByTail(List L){
      Node* p = L->next,*temp;
      while (p->next->next != NULL) { //找到尾节点的前一个结点
          p = p->next;
      }
      //开始删除结点
      temp = p->next;
      p -> next = NULL;
      free(temp);
  }
  void DeleteByValue(List L,int value){
      Node *p = L, *temp,*pre;
      while (p != NULL){
          if(p->data == value){  //找到要删除的元素结点
              //利用前一个节点删除该结点
              temp = p;
              pre -> next = p -> next;
              p = pre -> next;
              free(temp);
              continue;
          }
          pre = p;
          p = p->next;
      }
  }
  int SelectByIndexReverse(List L,int index){
      Node *slow = L, *fast = L;
      int i;
      for(i=1;i<index;i++){  //快指针向后移动index位
          fast = fast->next;
      }
      while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index位置
          fast = fast->next;
          slow = slow->next;
      }
      return slow->data;
  }
  void DeleteByIndexReverse(List L,int index){
      Node *slow = L, *fast = L,*temp;
      int i;
      for(i=0;i<index;i++){  //快指针向后移动index+1位
          fast = fast->next;
      }
      while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index的前一个位置
          fast = fast->next;
          slow = slow->next;
      }
      //删除结点
      temp = slow->next;
      slow->next = slow->next->next;
      free(temp);
  }
  

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^