C++ 何时删除karatsuba'；s算法？

这是我对karatsuba算法的实现， 当删除部分被注释时，它工作得很好，但是当我将其插入代码时，它会导致错误的输出
（例如，对于测试n=5，a=b={1,2,3,4,5}）

void conv（inta[]，intb[]，intc[]，intn）
{
如果（n==1）
{
c[0]=a[0]*b[0]；
返回；
}
int*C0=新的int[n]；
int*C1=新的int[n]；
int*C2=新的int[n]；
conv（a、b、C0、n/2）；
conv（a+n/2，b+n/2，C1，n/2）；
对于（int i=0；i

删除有什么问题？我是否以错误的方式释放了分配的内存？

---

提前谢谢

您可以将它们声明为向量，而不是声明为指针，这样就不必担心删除。删除的问题在于代码参数中，实际上是将c作为指针发送的，因此，当删除指针时，仍然指向已删除的地址，而不是值。

在此循环中：

for (int i = 0; i < n; i++) {
        c[i] += C0[i];
        c[i + n] += C1[i];
        c[i + n/2] += C2[i] - C1[i] - C0[i];
    }

for（int i=0；i

您正在添加从未初始化过的

c

元素。（可能您打算将它们初始化为0，否？）

我不知道您使用的是什么平台，但让我们假设它是一个平台，在这个平台上，当没有内存被释放时，新的内存分配恰好都是零，但一旦内存分配被释放，就有可能接收到释放的分配，它将具有随机值。在这种情况下，删除

delete

语句更有可能使所有内存分配都是新的，而包含它们则极有可能使内存块被回收

---

在任何情况下，使用未初始化的值都是未定义的行为。您可能应该显式地将新分配的

C0

、

C1

和

C2

向量设置为0。

您可以定义IntArray类，并在堆栈上创建它，而不是直接分配内存。通过这种方式，定义的类管理分配的内存本身。（当它超出范围时，会释放其成员int数组“data”。）

class IntArray{
公众：
int*数据；
int n；
IntArray（国际北）{
这个->n=n；
数据=新整数[n]；
对于（int i=0；iUse
std:：vector
。您的代码中有一部分是可疑的：您将c vector中的一个值设置为i+n。这是向量a、b和c的范围（我猜是n，但没有说明）。a和b的大小为n，但c的大小为2n。（我们将大小为n的c传递给具有新n=n/2的调用）在使用C0/C1/C2数组之前，您似乎没有完全初始化它们。您没有问，但我告诉您：这样动态分配和删除您的工作区会使Karatsuba比简单的逐字节乘法慢。相反，您应该在递归的顶层分配三个大数组，并使用动态poi在每次函数调用中，c的大小等于2*n（当我将n/2传递给函数时，传递的数组的大小为n）。所以c[0]…c[2n-1]元素以前已经初始化过！这是真的吗？现在我明白你的意思了！你是对的；）这一行解决了问题：fill（c，c+2*n，0）；
for (int i = 0; i < n; i++) {
        c[i] += C0[i];
        c[i + n] += C1[i];
        c[i + n/2] += C2[i] - C1[i] - C0[i];
    }

class IntArray{
public:
int* data;
int n;
IntArray(int n){
    this->n = n;
    data = new int[n];
    for(int i=0; i<n; i++){
        data[i] = 0;
    }
}
~IntArray(){
    if(data != NULL){
        delete[] data;
        data = NULL;
    }
}

};

void conv(int a[], int b[], IntArray &c, int n)
{
if (n == 1)
{
    c.data[0] = a[0]*b[0];
    return;
}
/*
int *C0 = new int[n];
int *C1 = new int[n];
int *C2 = new int[n];
*/
IntArray C0(n);
IntArray C1(n);
IntArray C2(n);

conv(a, b, C0, n/2);
conv(a + n/2, b + n/2, C1, n/2);
for (int i = 0; i < n/2; i++)
    a[i] += a[i + n/2], b[i] += b[i + n/2];
conv(a, b, C2, n/2);
for (int i = 0; i < n/2; i++)
    a[i] -= a[i + n/2], b[i] -= b[i + n/2];
for (int i = 0; i < n; i++)
{
    c.data[i] += C0.data[i];
    c.data[i + n] += C1.data[i];
    c.data[i + n/2] += C2.data[i] - C1.data[i] - C0.data[i];
}
}