main函数调用了子函数B，结果在执行完B后程序直接跳转到另外一个子函数C处（C也调用了B，B执行完
直接跳转到C调用B的地方）。这是为什么啊？
我查了查网上的回答，说是数组越界/指针的问题。
请各位大神指点指点出现这种情况问题都有可能是什么？我好自检代码。

把代码发上来瞅瞅更好看清楚你出的问题哦,最后附上你编译提示的错误

楼主。你这种只有问题没有提供代码，我只能看到你说了  main函数调用函数B,函数B调用了函数C。。。。。
你突然说数组指针越界的问题。。。
我实在不明白你想在这里得到什么答案？？

代码太长了，不好贴。
我的确是问问题表述不清楚，检讨。。。
问题简单来说是：子函数执行完后没有返回调用它的主函数，而是返回到另外一个函数中（该函数也调用了子函数），这个可能是什么原因造成的？
另外，我说越界指针等问题是网上搜到的一些答案，想从这里得到的就是我遇到的这个问题是否常见？出现这种问题的原因可能是什么？

那你就贴部分代码啊，你这啥都没看，出现的问题让人猜，这个难度是真的大。。返回值不对，那最可能就是return语句啊。还有就是什么无条件跳转，谁知道你到底啥问题啊。不容易猜

贴代码最好，建议检查一下循环语句。
Windows下拿VS，Linux下拿GDB单步调试一下也可。

//B函数调用C函数
B()
{
    C();
}
//C函数调用B函数
C()
{
    B();
}

//入口为B函数
main()
{
    B();
}

像你描述的那样，是不是像我以上写的？要是这样的话，如无限制条件，会不断的在B函数和C函数之间循环执行。。
至于你说的指针越界的问题。那是指针的问题了。
末了，楼主无法贴代码，那么就设置断点单步调试看看好了。。
猜答案这东西实在不是编程人员该做的事。

你给代码才知道，按照你的说法应该是你在子函数里在此调用了子函数。
当你执行完那些子函数才能回到main方法里继续执行啊

好的，这是代码，单步调试也做了，从main函数的fft执行完，直接跳到子函数SquareFFT调用fft函数处了。程序不报错，只是就停到那里了

typedef struct _complex_ //复数类型  
{  
    float real;       //实部  
    float imag;       //虚部  
}complex;
void main(short start1, short end1, short start2, short end2, float *x1, float *x2， short N1， short N2){
        float *R1; 
        float *R2; 
        float *g1; 
        float *g2; 
        complex *G1; 
        complex *G2; 

        R1=(float *)malloc(N1*sizeof(float));
    R2=(float *)malloc(N1*sizeof(float));
    g1=(float *)malloc(sizeof(float)*N1);
    g2=(float *)malloc(sizeof(float)*N2);
    G1 = (complex *)malloc(sizeof(complex) * N1);
    G2 = (complex *)malloc(sizeof(complex) * N2);

    for(i=start1;i<end1;i++){
        g1[i-start1]=x1[i];
    }
    for(i=start2;i<end2;i++){
        g2[i-start2]=x2[i];
    }   
   
    memset(G1, 0, sizeof(complex) * N1);
    memset(G2, 0, sizeof(complex) * N2);

    for (i = 0; i < N1; i++)             //实部赋值，虚部为零
    {
        G1[i].real = g1[i];
    }
    for (i = 0; i < N2; i++)             //实部赋值，虚部为零
    {
        G2[i].real = g2[i];
    }
    
    fft(N1,G1);                //程序执行到此处出现问题
    fft(N2,G2);
}


子函数1
//傅里叶变化
void fft(int N,complex *f)
{
    complex t,wn;//中间变量
    int i,j,k,m,n,l,r,M;
    int la,lb,lc;
    /*----计算分解的级数M=log2(N)----*/
    for(i=N,M=1;(i=i/2)!=1;M++);
    /*----按照倒位序重新排列原信号----*/
    for(i=1,j=N/2;i<=N-2;i++)
    {
        if(i<j)
        {
            t=f[j];
            f[j]=f[i];
            f[i]=t;
        }
        k=N/2;
        while(k<=j)
        {
            j=j-k;
            k=k/2;
        }
        j=j+k;
    }

    /*----FFT算法----*/
    for(m=1;m<=M;m++)               //每一级
    {
        la=pow(2.0,m);              //la=2^m代表第m级每个分组所含节点数   即信号点数N
        lb=la/2;                    //lb代表第m级每个分组所含碟形单元数   即N/2
                                    //同时它也表示每个碟形单元上下节点之间的距离
        /*----碟形运算----*/
        for(l=1;l<=lb;l++)
        {
            r=(l-1)*pow(2.0,M-m);
            for(n=l-1;n<N-1;n=n+la)     //遍历每个分组，分组总数为N/la
            {
                lc=n+lb;                //n,lc分别代表一个碟形单元的上、下节点编号
                Wn_i(N,r,&wn,1);        //wn=Wnr
                c_mul(f[lc],wn,&t);     //t = f[lc] * wn复数运算
                c_sub(f[n],t,&(f[lc]));//f[lc] = f[n] - f[lc] * Wnr
                c_plus(f[n],t,&(f[n]));//f[n] = f[n] + f[lc] * Wnr
            }
        }
    }
}

子函数2
void squareFFT(int iLength, float *pSrc, float *pResult)
{
    int iLoop;
    complex *pstSrc = (complex *)malloc(sizeof(complex) * iLength);
    if (NULL == pstSrc)
    {
    printf("source wrong");
    }
    memset(pstSrc, 0, sizeof(complex) * iLength);

    for (iLoop = 0; iLoop < iLength; iLoop++)             //实部赋值，虚部为零
    {
        pstSrc[iLoop].real = pSrc[iLoop];
    }

    fft(iLength, pstSrc);                                  //////单步调试，main函数调用了fft执行完就跳到这一步了

    for (iLoop = 0; iLoop < iLength; iLoop++)
    {
        pResult[iLoop] = pstSrc[iLoop].real * pstSrc[iLoop].real + pstSrc[iLoop].imag * pstSrc[iLoop].imag;
    }

    free(pstSrc);
    
}

没有交叉调用，也试过单步调试。
代码已经贴出来了，多谢回答。