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

聲明; 函數：pfactorization應該找到一個數的素數因子分解。 它在函數的底部調用：prime_func。 數據正在從prime_func傳遞到pfactorization。 在添加此功能之前，代碼工作正常。

問題：我不明白這個錯誤信息。 它是什么意思，我應該如何解決它？

求助：int z_array [100]; 謝謝。

Answer 1

z_array聲明為int類型。 int既不是數組也不是指針:)

我猜你的意思是把它變成一個int* 。

Answer 2

我無法確定哪一行是正確的行，但這意味着你在不正確類型的東西上使用索引運算符“[]”。

blah[foo]

blah必須是類型數組或指針。

編輯：您的代碼：

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

z_array聲明為int，int不能被索引

Answer 3

z_array只是聲明為int ，並且您嘗試使用方括號（如數組）對其進行索引。

Answer 4

z_array不是整數數組，它是一個整數。 你不能像z_array [var]那樣將它包括在內。 要聲明一個數組，你可以做int z_array [100]。

Answer 5

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

z_array不是int[]或int* ，因此z_array[i]是荒謬的。

我懷疑你可能打算寫

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

或類似的東西。 我沒有挖到周圍的代碼來確定這是否真的是正確的大小。

Answer 6

你好像已經解決了你的問題，但你的程序正在爬行，有更微妙的問題。 我冒昧地為你改寫它。 我做出的每一次改變都有一個原因，即使是那些看似微不足道的改變。 請仔細閱讀並考慮為什么我做了我做的事情。 我很樂意回答有關變化的具體問題。

/* 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;
}