No idea where seg fault is occuring [closed] - c++

Question

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.
Closed 9 years ago.
For some reason, when I run this code, I get a seg fault when the value of i in the for-loop is 7654319. However the strange thing is that when I am not checking if the value is pan-digital, it works normally without a segfault. It also works when I am checking if it is just pandigital; but not for both. I used gdb to step through the code and here is the output I get:
Program received signal SIGSEGV, Segmentation fault.
0x00000000004007d3 in main () at Pand.cc:81
81 if (isPandigital(i) && Primes[i])
6: Primes[i] = <error: Cannot access memory at address 0x7ffefffffff4>
5: i = <error: Cannot access memory at address 0x7ffefffffff4>
4: Primes[7654317] = <error: Cannot access memory at address 0x7ffefffffff8>
3: Primes[7654321] = <error: Cannot access memory at address 0x7ffefffffff8>
2: Primes[7654319] = <error: Cannot access memory at address 0x7ffefffffff8>
1: Primes = <error: Cannot access memory at address 0x7ffefffffff8>
From the output, it seems that by manipulating the value of i in the isPandigital(int) function, this also affects value of i in main. This didn't make any sense to me, but I went ahead and used a different variable to represent i in the isPandigital(int) function, but I still get the same error.
Can someone help me please? These kind of errors are so annoying because everything seems like it should be working, but it's not and the solution is just hiding itself under layers of implementation. Any help is appreciated!
#include <cstdio>
#define MAX 7700000
typedef unsigned int uint;
bool* GetPrimes()
{
const int Need = MAX;
bool* Sieve = new bool[Need];
for (int s = 0; s < Need; ++s)
Sieve[s] = 1;
bool Done = false;
uint w = 3;
while (!Done)
{
for (uint q = 3, Prod = w * q; Prod < (uint)Need ; q += 2, Prod = w * q)
Sieve[Prod] = false;
Done = (w > (Need >> 1) ? true : false);
w+=2;
}
return Sieve;
}
bool isPandigital(int num)
{
int arr [] = {1,2,3,4,5,6,7}, G, count = 7;
do
{
G = num%10;
if (arr[G-1])
--count;
arr[G-1] = 0;
} while (num/=10);
return (!count);
}
int main()
{
bool* Prime = GetPrimes();
int i;
for (i = 7654321 ;i > 2; i-=2)
{
if (Prime[i] && isPandigital(i))
break;
}
printf("%d\n", i);
return 0;
}

Answer 1

In your isPandigital function. Notice that if num is a multiple of ten or congruent to 8 or 9 mod 10, you'll have a few problems. Out-of-bounds array accesses often lead to segfaults.
The first prime for which this occurs is 19 (or 7654319 if you go backwards from 7654321):
bool isPandigital(int num)//num is (76543)19
{
int arr [] = {1,2,3,4,5,6,7}, G, count = 7;
do
{
G = num%10; //G is 9
if (arr[G-1]) //G-1 is 8; G is only indexed from 0 to 6.
--count;
arr[G-1] = 0; //G-1 is 8; G is only indexed from 0 to 6.
} while (num/=10);
return (!count);
}
Note that though the solution will not have an 8 or 9 in it, any prime you test might.

Answer 2

Look at:
G = num%10;
if (arr[G-1])
So, what if G is zero? This would also trash your stack, making debug hard.
On the face of it, isPandigital works nicely in the case when the number passed is pan-digital, else has an array bound under/overrun?