beendet durch Signal SIGSEGV (Address Boundary Error) in rekursiver Funktion

Question

Ich versuche Karatsuba Algorithmus für Multiplikation zu implementieren. Ich folge dem Pseudocode in diesem Wiki page. Aber ich bin immer immer diese Fehlermeldung:

terminated by signal SIGSEGV (Address boundary error)

Wenn ich die Zeilen ersetzt, die die Rekursion verursachen mit etwas passieren anderes:

z0 = multiply(a, c); 
z1 = multiply(b, d); 
z2 = multiply(a+b, c+d); 

der Fehler verschwunden.

Hier ist mein Code:

#include <iostream> 
#include <math.h> 

long int multiply(int x, int y); 
int get_length(int val); 

int main() 
{ 
    int x = 0, y = 0; 
    long int result = 0; 

    std::cout << "Enter x: "; 
    std::cin >> x; 
    std::cout << "Enter y: "; 
    std::cin >> y; 

    result = multiply(x, y); 
    std::cout << "Result: " << result << std::endl; 
    return 0; 
} 

long int multiply(int x, int y) 
{ 
    if(x < 10 || y < 10) { 
    return x * y; 
    } 

    int x_len = get_length(x); 
    int y_len = get_length(y); 

    long int z0 = 0 , z1 = 0, z2 = 0; 
    int a = 0, b = 0, c = 0, d = 0; 

    a = x/pow(10, x_len); 
    b = x - (a * pow(10, x_len)); 
    c = y/pow(10, y_len); 
    d = y - (c * pow(10, y_len)); 

    z0 = multiply(a, c); 
    z1 = multiply(b, d); 
    z2 = multiply(a+b, c+d); 

    return (pow(10, x_len) * z0) + (pow(10, x_len/2) * (z2 - z1 - z0)) + z1; 
} 

int get_length(int val) 
{ 
    int count = 0; 
    while(val > 0) { 
    count++; 
    val /= 10; 
    } 
    return count; 
} 

Answer 1

Ich fand die Ursache des Problems. Es war wegen dieser Zeilen:

a = x/pow(10, x_len); 
b = x - (a * pow(10, x_len)); 
c = y/pow(10, y_len); 
d = y - (c * pow(10, y_len)); 

Es x_len/2 statt sein sollte x_len und das gleiche mit y_len. Da es bewirkt, dass die Rekursion unendlich ist.

Answer 2

Sie verwenden die pow Funktion ganzzahlige Potenzen zu tun. Es ist keine ganzzahlige Funktion. Codieren Sie Ihre eigene pow Funktion, die für Ihre Anwendung geeignet ist. Zum Beispiel:

int pow(int v, int q) 
{ 
    int ret = 1; 
    while (q > 1) 
    { 
     ret*=v; 
     q--; 
    } 
    return ret; 
} 

Stellen Sie sicher, ein int pow(int, int); an der Spitze zu setzen.