把阶乘运算包到函数里，这个代码哪里写错了？


#include <iostream>
using namespace std;
long long int change(int number)
{
    long long int nb=1;
     for (long long int i=1;i <= number;i++)
    {
        nb*=i;
    }
    return nb;
}
int main()
{
    long long int in_nb,pr_nb=1;
    cin >> in_nb;
    pr_nb=change(in_nb);
    cout << endl << pr_nb;
    return 0;
}

number是循环结束条件，可你循环体里不断在修改number啊


int change(int number)
{
    int res = 1;
    for (int i=1;i <= number;i++)
    {
        res = res *i;
    }
    return res ;
}

这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7597119
这篇博客也不错, 你可以看下循环和递归可以相互替代吗？
除此之外, 这篇博客: 什么是栈？中的 代码实现 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

顺序栈：

栈的顺序存储结构简称顺序栈；
利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素；
同时附设指针top指示栈顶元素在顺序表中的位置；

1，先写实体类SeqStack；

属性有栈的容量，结点数据以及栈的实际大小（即长度）

package com.java.model;

public class SeqStack {
    //动态数组的最大容量
    public final static int Max_Size=1024;

    //栈的结点数据
    public Object[] data;
    //栈的长度，用来标识数组中的元素个数
    public int size;

    //构造函数
    public SeqStack(Object[] data, int size) {
        this.data = data;
        this.size = size;
    }
}

2，写栈的方法类SeqStackDao；

包括入栈、出栈、查看栈顶元素等等；

package com.java.dao;

import com.java.model.SeqStack;

import static com.java.model.SeqStack.Max_Size;

public class SeqStackDao {
    //初始化栈
    public SeqStack Init_SeqStack(){
        //动态数组初始化，加数组容量
        Object[] data1=new Object[Max_Size];

        //栈初始化，元素个数size为0
        SeqStack stack=new SeqStack(data1,0);

        //数组赋值
        for(int i=0;i<Max_Size;i++){
            stack.data[i]=0;
        }
        return stack;
    }
    //入栈
    public void Push_SeqStack(SeqStack stack,Object data){
        if(stack==null){
            return;
        }
        if(data==null){
            return;
        }
        //如果栈容量小于或等于数组容量
        if(stack.size==Max_Size){
            return;
        }
        //元素入栈
        stack.data[stack.size]=data;
        stack.size++;
    }
    //查找栈顶元素
    public Object Top_SeqStack(SeqStack stack){
        if(stack==null){
            return null;
        }
        //若栈元素为0，则返回null
        if(stack.size==0){
            return null;
        }
        //栈顶元素，注意数组下标从0开始，所以要减1
        Object o=stack.data[stack.size-1];
        return o;
    }
    //出栈操作
    public void Pop_SeqStack(SeqStack stack){
        if(stack==null){
            return;
        }
        if(stack.size==0){
            return;
        }
        //出栈
        stack.size--;
    }
    //判断是否为空
    public boolean IsEmpty(SeqStack stack){
        if(stack==null){
            return false;
        }
        if(stack.size==0){
            return true;
        }
        return false;
    }
    //返回栈中元素的个数
    public int Size_SeqStack(SeqStack stack){
        return stack.size;
    }
    //清空栈
    public void Clear_SeqStack(SeqStack stack){
        if(stack==null){
            return;
        }
        for(int i=0;i<stack.size;i++){
            stack.data[i]=null;
        }
        stack.size=0;
    }
}

3，主函数Main；

包括主函数，来测试栈的各种方法；

package com.java.main;

import com.java.dao.SeqStackDao;
import com.java.model.SeqStack;

public class SeqStackMain {
    public static void main(String[] args) {
        SeqStackDao seqStackDao=new SeqStackDao();
        //初始化栈
        SeqStack stack=seqStackDao.Init_SeqStack();

        //入栈
        seqStackDao.Push_SeqStack(stack,"A");
        seqStackDao.Push_SeqStack(stack,"B");
        seqStackDao.Push_SeqStack(stack,"C");
        seqStackDao.Push_SeqStack(stack,"D");
        seqStackDao.Push_SeqStack(stack,"E");

        //输出栈元素
        while(stack.size>0) {
            //查找栈顶元素
            Object o = seqStackDao.Top_SeqStack(stack);
            System.out.println(o);
            //出栈
            seqStackDao.Pop_SeqStack(stack);
        }
    }
}

运行结果：

链栈：

栈的链式存储简称链栈；
存储结构类似于链表；

1，先写实体类LinkStackNode和LinkStack；

LinkStackNode:
包括链栈结点的数据域和指针域；
数据域是Object类型的，指针域是LinkStackNode类型的
LinkStack:
包括链栈的栈顶指针和链表元素个数；
栈顶指针是LinkStackNode类型的，链栈元素个数是int型的

package com.java.model;

public class LinkStackNode {
    //栈结点的数据域
    public Object data;
    //栈结点的指针
    public LinkStackNode next;

    //构造方法
    public LinkStackNode(Object data, LinkStackNode next) {
        this.data = data;
        this.next = next;
    }
}

package com.java.model;

public class LinkStack {
    //栈顶指针，也就是所谓的头结点
    public LinkStackNode head;
    //栈的容量
    public int size;

    public LinkStack(LinkStackNode head, int size) {
        this.head = head;
        this.size = size;
    }
}

2，写链栈的方法类LinkStackDao；

包括入栈，出栈等方法；

package com.java.dao;

import com.java.model.LinkStack;
import com.java.model.LinkStackNode;

public class LinkStackDao {
    //初始化栈
    public LinkStack Init_LinkStack(){
        //初始化栈顶指针
        LinkStackNode head=new LinkStackNode(0,null);
        //初始化栈
        LinkStack stack=new LinkStack(head,0);

        return stack;
    }

    //入栈
    public void Push_LinkStack(LinkStack stack,Object data){
        if (stack == null){
            return;
        }
        if (data == null){
            return;
        }
        //创建新插入的结点，也就是栈顶指针后面的第一个元素，因为只能在栈顶进行元素插入或删除
        LinkStackNode newNode=new LinkStackNode(data,null);
        //进入插入操作
        newNode.next=stack.head.next;
        //栈顶指针的next等于新插入结点
        stack.head.next=newNode;
        //栈容量加1
        stack.size++;
    }

    //出栈
    public void Pop_LinkStack(LinkStack stack){
        if (stack == null){
            return;
        }
        if (stack.size == 0){
            return;
        }
        //删除栈顶指针后面的第一个元素
        stack.head.next=stack.head.next.next;
        //栈容量减1
        stack.size--;
    }

    //返回栈顶元素
    public Object Top_LinkStack(LinkStack stack){
        if (stack == null){
            return null;
        }
        if (stack.size == 0){
            return null;
        }
        //栈顶元素也就是栈顶指针后面的第一个元素
        return stack.head.next.data;
    }

    //返回栈容量，也就是栈元素个数
    public int Size_LinkStack(LinkStack stack){
        if (stack == null){
            return -1;
        }
        return stack.size;
    }

    //清空栈
    public void Clear_LinkStack(LinkStack stack){
        if (stack == null){
            return ;
        }
        stack.head.next=null;
        stack.size=0;
    }
}

3，主函数；

主函数，包括测试链栈的方法；

package com.java.main;

import com.java.dao.LinkStackDao;
import com.java.model.LinkStack;

public class LinkStackMain {
    public static void main(String[] args) {
        LinkStackDao linkStackDao=new LinkStackDao();
        //初始化栈
        LinkStack stack=linkStackDao.Init_LinkStack();

        //入栈
        linkStackDao.Push_LinkStack(stack,"A");
        linkStackDao.Push_LinkStack(stack,"B");
        linkStackDao.Push_LinkStack(stack,"C");
        linkStackDao.Push_LinkStack(stack,"D");
        linkStackDao.Push_LinkStack(stack,"E");

        //输出栈元素
        while(stack.size>0){
            //查找栈顶元素
            Object o=linkStackDao.Top_LinkStack(stack);
            System.out.println(o);
            //出栈
            linkStackDao.Pop_LinkStack(stack);
        }
    }
}

运行结果：
在这里插入图片描述

好了，今天就分享到这里了，更多采用漫画趣解编程知识的文章，欢迎关注我的微信公众号，一起学习进步！嘿嘿~

原创实属不易，求个关注吧~

您还可以看一下王文凯老师的程序员的数学：优化理论课程中的参数少、迭代次数少的优化算法小节, 巩固相关知识点
以下回答由chatgpt基于相关博客总结生成:
我可以尝试帮你找出你的阶乘运算函数出错的原因。
可能出错的地方是在循环语句中，你可能没有正确控制循环次数，或者没有正确计算乘积。以下是一个正确计算阶乘的函数示例：
```
int factorial(int n) {
    if (n < 0) {  // 容错处理：负数没有阶乘，返回-1
        return -1;
    }
    int result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}
```
这个函数可以正确地计算正整数的阶乘，如果传入负数，函数返回-1表示错误。对于n等于0或1的情况，循环不会执行，直接返回1。
希望这个例子能够帮助你找出阶乘运算函数出错的原因。如果你还有其他需要帮助的问题，请继续发问。