C - 错误：下标值既不是数组也不是指针

Question

/*
 * File:   main.c
 * Author: matthewmpp
 *
 * Created on November 7, 2010, 2:16 PM
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

/*
prime numbers.
version4
should tell whether a number is prime or not prime.
by using other prime numbers.
 */

int input_func() {
    char line[100];
    int n_input;

    while (1) {
        printf("Please enter a whole number.\n");
        fgets(line, sizeof (line), stdin);
        sscanf(line, "%d", &n_input);

        if (n_input >= 0)
            break;

        return (n_input);
    }
}

int ifstatements_func(n_ifstate)
int n_ifstate;
{
    if (n_ifstate == 0) {
        printf("The number, %d, is not prime and has no factors.\n", n_ifstate);
        exit(1);
    }

    if (n_ifstate == 1) {
        printf("The number, %d, is not prime.\n", n_ifstate);
        printf("The factors of %d, is %d.\n", n_ifstate, n_ifstate);
        exit(1);
    }

    if (n_ifstate == 2) {
        printf("The number, %d, is a prime.\n", n_ifstate);
        printf("The factors of %d, are 1 and %d.\n", n_ifstate, n_ifstate);
        exit(1);
    }
    if (n_ifstate == 3) {
        printf("The number, %d, is a prime.\n", n_ifstate);
        printf("The factors of %d, are 1 and %d.\n", n_ifstate, n_ifstate);
        exit(1);
    }
    return (n_ifstate);
}

int square_root_func(n_prmfnc)
int n_prmfnc;
{
    int i; //counter

    float sq_root_f;
    int sq_root_i;

    int primes[100];
    int length_primes;

    primes[0] = 2; /*first prime is 2.*/
    primes[1] = 3; /*second prime is 3.*/
    length_primes = sizeof (primes);

    //printf ("before.sq_root.value of n_prmfnc=%d\n", n_prmfnc);
    sq_root_f = sqrt(n_prmfnc);
    sq_root_i = sq_root_f;
    //printf ("prmfnc.after.sq_root\n");
    //printf ("value of sq_root=%.3f\n", sq_root_f);
    //printf ("value of sq_root=%d\n", sq_root_i);

    return (sq_root_i);
}

int prime_func(sq_root_pf, n_pf)
int sq_root_pf;
int n_pf;
{
    //printf ("in.pf.beginning.of.func.sq_root_pf=%d\n", sq_root_pf);
    //printf ("in.pf.beginning.of.func.n_pf=%d\n", n_pf);

    int factor_counter = 0;
    int factor_temp;
    int prime_counter = 0;
    int prime_flag = 0;

    int primes_pf[100];
    int length_primes_pf = 0; //counter
    int i; //counter

    primes_pf[0] = 2;
    primes_pf[1] = 3;
    primes_pf[2] = 5;

    length_primes_pf = 3;
    //printf("length_primes_pf=%d\n", length_primes_pf);

    //printf ("before.for.in.pf\n");
    for (i = 0; i <= length_primes_pf; ++i) {
        //printf ("after.for.in.pf\n");
        if (primes_pf[i] == 0)
            printf("primes_pf=0");
        else {
            if (primes_pf[i] <= sq_root_pf) {
                //printf("primes_pf.i=%d, sq_root_pf=%d\n", primes_pf[i], sq_root_pf);
                //printf("before.modulus.in.pf\n");
                factor_temp = n_pf % primes_pf[i];
                //printf("after.modulus.in.pf\n");
                //printf("value.of.factor_temp=%d\n", factor_temp);
                if (factor_temp == 0) {
                    ++factor_counter;
                    //printf("value.factor_counter=%d\n", factor_counter);
                } else
                    ++prime_counter;

                if (factor_counter == 0 && prime_counter > 0) {
                    prime_flag = 1; /*yes, number is prime.*/
                    primes_pf[length_primes_pf + 1] = n_pf;
                    //printf("length_primes_pf=%d\n", length_primes_pf);
                }
            }

        }
    }

    if (prime_flag == 1) {
        printf("The number, %d, is prime.\n", n_pf);
        printf("The factors of %d, is 1 and %d.\n", n_pf, n_pf);
        exit(0);
    } else
        printf("The number, %d, is not prime.\n", n_pf);

    if (prime_flag == 0)
    pfactorization (primes_pf, length_primes_pf, n_pf);

    return (prime_flag);
}

int pfactorization(primes_fac, length_primes_fac, n_fac)
int primes_fac[];
int length_primes_fac;
int n_fac;
{
    int i;
    int j;

    int result;
    int n_temp;

    int z_array;
    int length_z_array=0;

    for (i=0; i<=length_primes_fac; ++i) {
        result = n_fac%primes_fac[i];
        if (result == 0) {
            n_temp = n_fac/primes_fac[i];
            z_array[length_z_array]=primes_fac[i];
            ++length_z_array;
        }
    }

    printf ("The prime factorization is:");
    for (j = 0; j < length_z_array; ++j)
        printf("%d\n", z_array[j]);
}

int factors_func(n_ff)
int n_ff;
{
    int i;
    int j;

    int result;

    int factors[100];
    int length_factors = 0;

    for (i = 2; i < n_ff; ++i) {
        result = n_ff % i;
        if (result == 0) {
            factors[length_factors] = i;
            ++length_factors;
        }
    }

    printf("The factors for %d are:\n", n_ff);
    printf("1\n");

    for (j = 0; j < length_factors; ++j)
        printf("%d\n", factors[j]);

    printf("%d\n", n_ff);

    return (EXIT_SUCCESS);
}

int main() {
    int n_main1; //number from input
    int n_main2; //number after if statements
    int sq_root_main; //square root of number from function
    int prime_flag_main; //value of 1 if it is a prime

    n_main1 = input_func();
    //printf("main.after.input.function=%d.\n", n_main1);

    n_main2 = ifstatements_func(n_main1);
    //printf("main.after.ifstatments.function=%d\n", n_main2);

    sq_root_main = square_root_func(n_main2);
    //printf("main.after.square_root_func_func=%d\n", sq_root_main);

    prime_flag_main = prime_func(sq_root_main, n_main2);
    //printf("main.after.prime_func=%d\n", prime_flag_main);

    factors_func(n_main2);



    return (EXIT_SUCCESS);
}

OUTPUT:

matthewmpp@annrogers:~/Programming/C.progs/Personal$ vim prime6.c
matthewmpp@annrogers:~/Programming/C.progs/Personal$ cc -c prime6.c
prime6.c: In function ‘pfactorization’:
prime6.c:171: error: subscripted value is neither array nor pointer
prime6.c:178: error: subscripted value is neither array nor pointer

STATEMENT; The function: pfactorization is supposed to find the prime factorization of a number. It is called at the bottom of function: prime_func. Data is being passed from prime_func to pfactorization. Code was working fine before I added this function.

QUESTION: I don't understand this error message. What does it mean and how should I fix it?

SOLVED: int z_array[100]; Thanks.

Answer 1

z_array is declared to be type int . int is neither an array nor a pointer :)

I'm guessing you meant to make it an int* .

Answer 2

I can't tell which line is the correct line, but what that means is that you're using the indexing operator "[]" on something that isn't the correct type.

blah[foo]

blah must be of type array, or pointer.

Edit: Your code:

int z_array;
.....
      z_array[length_z_array]
.....
   printf("%d\n", z_array[j]);

z_array is declared as an int, int's can't be indexed

Answer 3

z_array只是声明为int ，并且您尝试使用方括号（如数组）对其进行索引。

Answer 4

z_array is not an array of integers it is a single integer. You cannot subsript it like z_array[var]. To declare an array you can do int z_array[100] for example.

Answer 5

int z_array;
z_array[length_z_array]=primes_fac[i];
printf("%d\n", z_array[j]);

z_array is not an int[] or an int* , thus z_array[i] is nonsensical.

I suspect you may have intended to write

int *z_array = malloc((length_primes_fac + 1) * sizeof(int));
...
free(z_array);

or something similar. I haven't dug into the surrounding code to determine if that's realy the correct size or not.

Answer 6

You seem to have solved your immediate problem, but your program is crawling with more subtle problems. I have taken the liberty of rewriting it for you. There is a reason for every change I made, even the ones that seem trivial. Please read it carefully and consider why I did what I did. I am happy to answer specific questions about the changes.

/* factor.c - produce the prime factorization of a number.
   Uses the Sieve of Eratosthenes.  */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

static unsigned char *
compute_sieve(unsigned long root)
{
    unsigned char *sieve = malloc(root + 1);
    unsigned long i, j;

    /* all numbers are prime till proven otherwise */
    memset(sieve, 1, root + 1);

    /* 0 and 1 are not prime */
    sieve[0] = 0;
    sieve[1] = 0;

    for (i = 2; i <= root; i++) {
        if (!sieve[i])
            continue;
        for (j = 2; i*j <= root; j++)
            sieve[i*j] = 0;
    }

    return sieve;
}

static unsigned long *
compute_factors(unsigned long number, const unsigned char *sieve,
                unsigned long root, int *isPrime)
{
    unsigned long i;
    unsigned long *factors = calloc(root + 1, sizeof(unsigned long));

    *isPrime = 1;

    /* trial division by each prime in turn, starting with 2.  */
    for (i = 2; i <= root; i++) {
        if (!sieve[i])
            continue;
        while (number % i == 0) {
            *isPrime = 0;
            number /= i;
            factors[i]++;
        }
    }

    return factors;
}

static void
factor(unsigned long number)
{
    unsigned long root, i;
    unsigned char *sieve;
    unsigned long *factors;
    int isPrime;

    /* weed out base cases */
    if (number <= 3) {
        printf(" %lu\n", number);
        return;
    }

    /* sieve needs to go up to the square root of NUMBER */
    root = (unsigned long) floor(sqrt(number));
    sieve = compute_sieve(root);
    factors = compute_factors(number, sieve, root, &isPrime);

    if (isPrime)
        printf(" %lu\n", number);
    else {
        for (i = 2; i <= root; i++) {
            while (factors[i]) {
                printf(" %lu", i);
                number /= i;
                factors[i]--;
            }
        }
        if (number > 1)
          printf(" %lu", number);
        putchar('\n');
    }

    free(sieve);
    free(factors);
}

static void
usage(char **argv)
{
    fprintf(stderr, "usage: %s NUMBER\n"
            "NUMBER must be a non-negative integer\n",
            argv[0]);
}

int
main(int argc, char **argv)
{
    unsigned long number;
    char *endptr;

    if (argc != 2) {
        usage(argv);
        return 1;
    }

    number = strtoul(argv[1], &endptr, 10);
    if (endptr == argv[1] || *endptr != '\0') {
        usage(argv);
        return 1;
    }

    factor(number);
    return 0;
}