Thread: Segmentation Fault 11, Looking for a layman's terms explanation

So I finally finished up my first "real" C++ program which was trying to solve Problem 3 from Project Euler. It runs as expected except for when large values are entered. If I enter a value such as 1234567, I get a Segmentation Fault: 11. My guess is it has something to do with an overflow of memory or something, but I have no idea how to track it down, and the tutorial here was well over my head. Being very new to compiled languages, I am still learning all of the terminology and nuances as compared to my first language, MATLAB. Any help on the segmentation fault, as well as general comments about style or other tips you may have for a new C++ programmer would be greatly appreciated! If you do make any comments, please try to keep them "in English" for me. I plan to get there with the terminology, but it's a lot to learn.

Also, if any efficiency problems are pointed out, do me a favor and just address the loop or segment of code that can be optimized. I like the challenge of figuring out the optimization, and I know this code is not even close to fully optimized, just not sure where to start.

Thanks in advance!

Code:

//============================================================================
// Name        : Problem_03.cpp
// Author      : Stefano Prezioso
// Version     :
// Copyright   : 
// Description : Project Euler Problem 3
//============================================================================


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


using namespace std;


int main() {
    //Declare variables
    int counter = 0;


    double value, quotient = 0;


    //Declare value to find the largest prime value of
    //Goal Value is 600851475143
    cout<< "Enter a value: "; cin>>value;
    cin.ignore();


    //Calculate iVal for efficiency of following for loops
    int iVal = value/2 +1;


    //Declare array. Can I make this a static array while still using the value of halfVal somehow? I don't need a dynamic allocation of memory.
    double factors[iVal];


    //Determine the quotient of the value divided by num (from 2 to iVal) for logical test
    for (double num = 1; num < iVal; num = num + 2) {


        quotient = (value / num);


        //Print equation to calculate quotient in each iteration
        //cout << value << " / " << num << " = " << quotient << "\n";


        //Logical test to determine whether or not num is a factor. If so, store in factors array and update counter
        if (quotient == floor(quotient)) {
            factors[counter] = num;
            counter = counter + 1;
        }
    }


    //        //Print Factors of Value
    //        for (int i = 0; i < counter; i++) {
    //
    //            cout << "Factor: " << factors[i] <<"\n";
    //        }


    int numFactors = counter;


    //printf("Counter: %i\n", counter);


    double subValues[iVal];


    counter = 0;


    quotient = 0;


    double primeFactors[iVal];


    double i;
    int j;


    //Determine which factor to analyze
    for (int position = 0; position < numFactors; position++) {


        //printf("Factor being tested: %.0f\n", factors[position]);


        //Builds array subValues with possible factors of factor
        for (i = 1, j = 0; i < (factors[position] + 1); i++, j++) {


            subValues[j] = i;


            //printf("Subvalue: %.0f\nj: %i\n", subValues[j], j);
        }


        int flag = 0;


        //Divide current factor n by all values from 2 to n-1 to determine primeness
        for (int k = 1; k < factors[position] - 1; k++) {


            //printf("Evaluated Factor: %.0f\n", factors[position]);


            double currentVal = factors[position];


            quotient = currentVal / subValues[k];


            //printf("k Value: %i\nsubValues[k] Value: %f\nQuotient: %.2f\n", k, subValues[k], quotient);


            double roundedQuotient = ceil(quotient);


            //Flag non-prime numbers
            if (quotient == roundedQuotient) {


                flag = 1;


            }
        }
        //Store prime factors in array
        if (flag == 0) {


//            printf("Factors[position]: %.0f\n", factors[position]);


//            printf("counter: %i\n", counter);


            primeFactors[counter] = factors[position];


            counter = counter + 1;
        }
    }


    printf("Value is: %.0f\n", value);


//    printf("Number of factors: %i\n", numFactors);


    printf("Number of Prime Factors: %i\n", counter);


    printf("Largest prime factor is: %.0f\n", primeFactors[counter - 1]);


    cout<< "Press enter to end program.";


    cin.get();
}

Originally Posted by msh

(2) Include `<limits>` and do `std::cout << "Largest value that can be stored by type int = " << std::numeric_limits<int>::max() << std::endl;` and consider the output in the light of what you're trying to do.

Alright, so my goal value is greater than the max value of the int data type. It should still be within the limits of the double data type, right? Is this causing an issue with iVal? The contraints of the different data types are something I am still learning. Any clarification would be greatly appreciated.

Originally Posted by msh

(4) Compact and reorganize your code to achieve logical grouping. Otherwise your code is near-impossible to read.

I'm all for trying to make my code clear and readable! Can you be more specific with what you mean by this? Since I'm new to this, I'm not sure what you mean by logical grouping.

Yeah, I realize I do now! That was an old comment from when I had everything done in predetermined values. I've implemented std::vector and it works great! I'm now running into a different issue when I push to even larger numbers, and getting an error that says, "terminate called throwing an exceptionAbort trap: 6". My guess is that I am requiring more memory than the stack allows, but I'm not sure how to get more memory through allocation. Any tips?

Or rather than code, you could always use one of those giant lists of primes available elseweb to see if some number is prime or not.