c - 如何解决 "undeclared"参数的错误，和/或可能合并指针

Question

使用 gcc 我收到以下错误，我不确定是否解决未声明的错误。

V_TRAP.c:在函数“my_func”中:

V_TRAP.c:168:22:错误:“a”未声明(在此函数中首次使用)部分总和 = (f(a) + f(b))/2.0;

V_TRAP.c:168:22:注意:每个未声明的标识符对于它出现的每个函数仅报告一次

V_TRAP.c:168:29:错误:‘b’未声明(在此函数中首次使用)部分总和 = (f(a) + f(b))/2.0; ^V_TRAP.c:172:37:错误:‘h’未声明(在此函数中首次使用)partial_sum += f((a)+i*(h));

 /*
  * This version does not make use of any atomics.

  *Input:   a, b, n, num_threads
  * Output:  Estimate of integral from a to b of f(x)
  *          using n trapezoids, with num_threads.
   * Compile: gcc -o trap V_TRAP.c -O3 -std=c99 -Wall -lpthread -lm
  * Usage:   ./V_TRAP

  *  */


 #define _REENTRANT
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/time.h>
 #include <math.h>
 #include <pthread.h>//
 #ifdef _WIN32
 #  define NOMINMAX 
 #endif

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



 /* Data structure defining what to pass to each worker thread. */
 typedef struct thread_data_s {
 int tid;                        /* The thread ID. */
 float a;                        /* Pointer to a. */
 float b;                        /* Pointer to b. */
 int num_trapezoids;             /* Number of trapezoids in the 
 float h;                    /* Pointer to base lenght of trapezoid */
 int num_threads;                /* Number of threads in the pool. */
 int offset;       /* Starting offset for each thread
 int chunk_size;                 /* Chunk size. */
 double *partial_sum;  /* Starting address of the partial_sum array. */
 } thread_data_t;

 /* Function prototypes. */

 double compute_using_pthreads (float , float , int, float , int);
 void *my_func (void *);
 void print_args (thread_data_t *);

 int 
 main (int argc, char **argv)
 {

   if (argc < 5) {
      printf ("Usage: trap lower-limit upper-limit num-trapezoids 
      num-  threads\n");
    printf ("lower-limit: The lower limit for the integral\n");
    printf ("upper-limit: The upper limit for the integral\n");
    printf ("num-trapezoids: Number of trapeziods used to 
     approximate the area under the curve\n");
    printf ("num-threads: Number of threads to use in the
    calculation\n");
    exit (EXIT_FAILURE);
 }

float a = atof(argv[1]); /* Lower limit */
float b = atof(argv[2]); /* Upper limit */
float num_trapezoids = atof(argv[3]); /* Number of trapezoids */

float h = (b - a)/num_trapezoids; /* Base of each trapezoid */  
printf ("The base of the trapezoid is %f \n", h);




/* Compute the using the multi-threaded solution. */

   int num_threads = atoi(argv[5]); /* Number of threads */
struct timeval start, stop; 
gettimeofday (&start, NULL);

double mt_result = compute_using_pthreads (a, b, 
     num_trapezoids, h, num_threads);

    gettimeofday (&stop, NULL);
printf ("Pthread solution = %f. \n", mt_result);
printf ("Execution time = %fs. \n", (float)(stop.tv_sec - 
    start.tv_sec +\
            (stop.tv_usec - start.tv_usec)/(float)1000000));
printf ("\n");

    /* Free memory here. */ 
//free ((void *) a);
//free ((void *) b);

pthread_exit (NULL);
    }//------------------------------------- END OF MAIN 



 * Function:    f
 * Purpose:     Defines the integrand
 * Input args:  x
 * Output: sqrt((1 + x^2)/(1 + x^4))

 */
 float 
 f (float x) 
{
    return sqrt ((1 + x*x)/(1 + x*x*x*x));
 }


/* This function computes using pthreads. */
double 
compute_using_pthreads (float a, float b, int num_trapezoids, float h, 
int num_threads)
{
  pthread_t *thread_id = (pthread_t *) malloc (num_threads * sizeof 
(pthread_t)); /* Data structure to store the thread IDs. */
  pthread_attr_t attributes; /* Thread attributes. */
  pthread_attr_init (&attributes); /* Initialize the thread attributes
 to 
the default values. */

  /* Allocate memory on the heap for the required data structures and  
 create the worker threads. */
  int i;
  double *partial_sum = (double *) malloc (sizeof (double) * 
 num_threads); /* Allocate memory to store partial sums returned by the 
  threads. */
   thread_data_t *thread_data = (thread_data_t *) malloc (sizeof 
 (thread_data_t) * num_threads);
   int chunk_size = (int) floor ((float) num_trapezoids/(float) 
   num_threads); /* Compute the chunk size. */

   for (i = 0; i < num_threads; i++) {
    thread_data[i].tid = i; 
    thread_data[i].a = a; 
    thread_data[i].b = b; 
    thread_data[i].num_trapezoids = num_trapezoids; 
    thread_data[i].h = h;
    thread_data[i].num_threads = num_threads;
    thread_data[i].offset = i * chunk_size; 
    thread_data[i].chunk_size = chunk_size;
    thread_data[i].partial_sum = partial_sum; 

 }

for (i = 0; i < num_threads; i++)
    pthread_create (&thread_id[i], &attributes, my_func, (void *) 
  &thread_data[i]);

/* Wait for the workers to finish. */
for (i = 0; i < num_threads; i++)
    pthread_join (thread_id[i], NULL);

/* Accumulate partial sums. */ 
double sum = 0.0; 
for (i = 0; i < num_threads; i++)
    sum += partial_sum[i];
    sum = sum*h;
/* Free dynamically allocated data structures. */
free ((void *) partial_sum);
free ((void *) thread_data);

return sum;

}

 /* This function is executed by each thread to compute the overall  
  result. */
  void *
 my_func (void *args)
  {

//    /* Typecast the argument to a pointer to the thread_data_t 
structure. */
thread_data_t *thread_data = (thread_data_t *) args;          

/* Compute the partial sum that this thread is responsible for. */
double partial_sum = 0.0; 
partial_sum = (f(a) + f(b))/2.0;

if (thread_data->tid < (thread_data->num_threads - 1)) {
    for (int i = thread_data->offset; i < (thread_data->offset + 
 thread_data->chunk_size); i++)
        partial_sum += f((a)+i*(h));
} 
else { /* This takes care of the number of trapezoids that the
 final thread must process. */
    for (int i = thread_data->offset; i < thread_data->num_trapezoids; 
 i++)
        partial_sum += f((a)+i*(h));
}

/* Store partial sum into the partial_sum array. */
thread_data->partial_sum[thread_data->tid] = partial_sum;

pthread_exit (NULL);
} 

/* Helper function. */
 void 
print_args (thread_data_t *thread_data)
{
printf ("Thread ID: %d\n", thread_data->tid);
printf ("Numer of threads: %d\n", thread_data->num_threads);
printf ("Num trapezoids: %d\n", thread_data->num_trapezoids); 
printf ("Address of vector A on heap: %p\n", &(thread_data->a));
printf ("Address of vector B on heap: %p\n", &(thread_data->b));
printf ("Offset within the vectors for thread: %d\n", 
thread_data->offset);
printf ("Chunk size to operate on: %d\n", thread_data->chunk_size);
printf ("\n");
}

Answer 1

函数 my_func 中不存在变量 a、b 和 h，即为什么您会收到有关未声明标识符的错误。

但是，这些名称是通过 void * 传递给该函数的 thread_data_t 的成员。您可能需要 thread_data->a、thread_data->b 和 thread_data->h。