Question

我试图遍历数组的元素，对于每个元素，我必须调用一个指向的函数，并传递元素地址以及存储在最后一个参数中的地址。并且该函数返回函数指向的元素数返回true。这是我一直试图遵循的要求，但我不能让我的功能完全按照要求去做。

------要求＆amp;功能------------

/* Write an enumeration function named sum() with the following parameters:

    a generic pointer
    an int that holds the number of elements in the array pointed to
    an int that holds the size in bytes of a single element
    a pointer to a function that has two generic pointer parameters and returns a bool
    a generic pointer

Your function moves through the array pointed to by the first parameter element by element.  
For each element, your function calls the function pointed to and passes the element's address    along 
with the address stored in the last parameter.  Your function returns the number of elements for 
which the function pointed to returned true. 

Since your first function parameter is a generic pointer and your function can handle any type, 
you will need to cast the address of the input array to the address of a chars in order to move 
from one element to the next.  */

int sum（void * x，int n，int s，bool（ f）（void ，void *），void * z）{

  char *arr = static_cast<char*>(x);

  int count = 0;
  for (; s < n-2; s++){
      arr += s;
      count += f(arr, z);     
  }
  if (n / 1 == n)
      return count;
  else if (n % 2 == 0)
      return count;
  else
      return 0;

}

我希望你们能告诉我并解释或者至少我正在以正确的方式做什么......我真的很感激这是唯一的方法，我可以学习.. :)

如果需要更多解释，请告诉我..

的的 ** * *** ADDITION 的 * ** * ***

/* Write a callback function named isEven() with the following parameters:

a generic pointer to an input value
a generic pointer to an output value

Your function works with ints and returns true if the input value is even, false otherwise.
Moreover, if the value is even, your function adds the value to that pointed to by the second
parameter. */

bool isEven(void* x, void* z){
  int a = *static_cast<int*>(x);
  int b = *static_cast<int*>(z);

  if (a % 2 == 0){ // finding even numbers
      b += a;
      return true;
  }
  else {
      return false;
  }
}

/* Write another callback function named isPrime() with the following parameters:

a generic pointer to an input value
a generic pointer to an output value

Your function works with ints and returns true if the input value is a prime number, false otherwise.
Moreover, if the value is prime, your function adds the value to that pointed to by the second
parameter. */

bool isPrime(void* x, void* z){
  int a = *static_cast<int*>(x);
  int b = *static_cast<int*>(z);

  if ((a / 1 == a) && (a / a == 1)){ // finding prime numbers
      b += a;
      return true;
  } 
  else {
      return false;
  }
}

的的 ** * ** * **** 预期输出 * ** * ** * ** * * < /强>

5 evens found in {1,2,3,4,5,6,7,8,9,10,11} sum is 30 5 primes found in {1,2,3,4,5,6,7,8,9,10,11} sum is 28

Answer 1

如果我理解正确，该功能将显示为

int sum( const void* x, int n, int s, bool(*f)( const void*, const void* ), const void* z )
{
   const char *p = reinterpret_cast<const char *>( x );

   int count = 0;
   for ( int i = 0; i < n; i++ )
   {
      count += f( p, z );
      p += s;
   }

   return count;
}

以下是使用函数

的示例

#include <iostream>
#include <cstdlib>
#include <ctime>

int sum( const void* x, int n, int s, bool(*f)( const void*, const void* ), const void* z )
{
   const char *p = reinterpret_cast<const char *>( x );

   int count = 0;
   for ( int i = 0; i < n; i++ )
   {
      count += f( p, z );
      p += s;
   }

   return count;
}

bool lt( const void *p1, const void *p2 )
{
    return ( *reinterpret_cast<const int *>( p1 ) <
             *reinterpret_cast<const int *>( p2 ) );
}

int main() 
{
    std::srand( ( unsigned int )std::time( 0 ) );

    const int N = 10;
    int a[N];

    for ( int &x : a ) x = std::rand() % N;

    for ( int x : a ) std::cout << x << ' ';
    std::cout << std::endl;

    int x = 5;

    int n = sum( a, N, sizeof( int ), lt, &x );

    std::cout << "There are " << n << " elements less than " << x << std::endl;

    return 0;
}

示例输出

4 7 2 9 2 8 6 1 9 9 
There are 4 elements less than 5

Answer 2

char* arr = (char*) x;

for(; s < (n-1); s++) 
{
    f((void*) &arr[s], z);
    // or
    f((void*) (arr + s * sizeof(char)), z);
}

函数通过元素在第一个元素指向的数组中移动

2 个答案: