/*
* 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);
}
输出：
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]; 感谢。
答案 0 :(得分：4)
z_array被声明为类型int。 int既不是数组也不是指针：）
我猜你的意思是让它成为int*。
答案 1 :(得分：2)
我无法确定哪一行是正确的行，但这意味着你在不正确类型的东西上使用索引运算符“[]”。
blah[foo]
blah必须是类型数组或指针。
编辑：您的代码：
int z_array;
.....
z_array[length_z_array]
.....
printf("%d\n", z_array[j]);
z_array声明为int，int无法编入索引
答案 2 :(得分：2)
z_array刚刚声明为int，您尝试使用方括号（如数组）对其进行索引。
答案 3 :(得分：2)
z_array不是整数数组，它是一个整数。你不能像z_array [var]那样将它包括在内。要声明一个数组，你可以做例如int z_array [100]。
答案 4 :(得分：1)
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);
或类似的东西。我没有挖掘周围的代码来确定它是否真的是正确的大小。
答案 5 :(得分：1)
您似乎已经解决了当前的问题，但您的程序正在抓取更微妙的问题。我冒昧地为你改写它。我做出的每一次改变都有一个原因，即使是那些看似微不足道的改变。请仔细阅读并考虑为什么我做了我做的事情。我很乐意回答有关更改的具体问题。
/* 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;
}