Question

我正在编写一个程序，当该数组的element = 1时，该数组返回另一个数组的索引作为元素。

因此，如果array [ix] = 1，则newarray [newarrcounter] = ix。

但是，返回的数组只有0作为元素。

我正在尝试仅使用指针而不使用索引。我在这里使用指针不正确吗？

int* primearr(int arr[], int size, int& newarrsize){
    int* end = arr + size;
    int* begin = arr;
      while(begin<end){
        if(*begin==1)
          ++newarrsize;
        begin++;
      }
      begin=arr;

    int *newarray= new int[newarrsize];
      while(begin<end){
        if(*begin==1){
          *newarray=begin-arr;
          newarray++;
        }
        begin++;
      }
    return newarray;
}

其余的程序代码...

#include <iostream>
#include <math.h>

using namespace std;
int* arr(int size);
int firstprime(int size, int arr[]);
void crossout(int size, int*arr, int factor);
void findzeros(int arr[], int size);
int* primearr(int arr[], int size,int& newarrsize);


int main()
{
    int low, high;
    char again='y';
    high=low=0;
    int firstn;
    int newarrsize=0;

    cout<<"\tThe Sieve of Eratosthenes"<<endl<<endl;
    do{
    do{
     do{
        cout<<"Enter the high boundary: ";
        cin>>high;
        cout<<endl;
        if(high<=0)
        cout<<"ERROR: HIGH BOUNDARY MUST BE POSITIVE"<<endl;
      }while(high<0);

      do{
        cout<<"Enter the low boundary: ";
        cin>>low;
        cout<<endl;
        if(low<=0)
        cout<<"ERROR: LOW BOUNDARY MUST BE POSITIVE"<<endl;
        }while(low<=0);
     if(low>high)
                cout<<"ERROR: HIGH BOUNDARY MUST BE GREATER THAN LOW BOUNDARY"<<endl;
    }while(low>=high);

    int* thearr= arr(high);

    firstn=firstprime(high,thearr);

    do{
      crossout(high,thearr,firstn);
      firstn=firstprime(high,thearr);
    }while(firstn<= sqrt(high));

    findzeros(thearr,high);

    int* thenewarr= primearr(thearr,high,newarrsize);

    cout<<"The prime numbers from "<<low<<" to "<<high<<" are: "<<endl;
    int* begin = thenewarr;
    int* end = thenewarr+newarrsize;
    while(begin<=end){
      cout<<*thenewarr<<"  ";
      ++begin;
    }

    cout<<endl<<endl;
    cout<<endl<<endl;
    cout<<"Try again with new boundaries? (y/n):"<<endl;
    cin>>again;

    delete[] thearr;
    delete[] thenewarr; 

    }while(again=='y');

   return 0;
}

int* arr(int size){
    int* thearray = new int[size]();
    thearray[0] = -1;
    thearray[1] = -1;
    return thearray;
}

int firstprime(int size, int arr[]){
  int* end = arr + size;
  int* begin = arr;
    while(begin<end){
        if(*begin==0)
            return (begin-arr);
        begin++;
    }
    return -1;
}

void crossout(int size, int*arr, int factor){
    int* end = arr + size;
    int* begin = arr;
    int newfactor=factor+factor;
    while(begin<end){
        if((begin-arr)==factor)
          *begin=1;
        else if((begin-arr)==newfactor){
          *begin=-1;
          newfactor=newfactor+factor;
        }
        begin++;
    }
}

void findzeros(int arr[], int size){
    int* end = arr + size;
    int* begin = arr;
    while(begin<=end){
        if(*begin==0)
            *begin=1;
        begin++;
    }
}

int* primearr(int arr[], int size, int& newarrsize){
    int* end = arr + size;
    int* begin = arr;
      while(begin<end){
        if(*begin==1)
          ++newarrsize;
        begin++;
      }
      begin=arr;

    int *newarray= new int[newarrsize];
      while(begin<end){
        if(*begin==1){
          *newarray=begin-arr;
          newarray++;
        }
        begin++;
      }
    return newarray;
}

Answer 1

在计算新数组的大小之前，您没有将newarrsize初始化为0。

分配新数组后，在填充新数组时，将增加指向新数组的指针。因此，当函数退出时，您没有返回指向新数组前面的指针，而是返回了超出新数组末尾的指针。这样不仅会阻止调用方访问所需的索引，而且还会阻止调用方在使用完数组后能够正确delete[]正确使用数组。

尝试以下方法：

int* primearr(int arr[], int size, int& newarrsize) {
    int* begin = arr;
    int* end = begin + size;

    newarrsize = 0;
    while (begin < end) {
        if (*begin == 1)
            ++newarrsize;
        ++begin;
    }

    int *newarray = new int[newarrsize];

    int *ptr = newarray;
    begin = arr;
    while (begin < end) {
        if (*begin == 1) {
            *ptr = begin - arr;
            ++ptr;
        }
        ++begin;
    }

    return newarray;
}

话虽如此，实际上您应该使用std::vector：

std::vector<int> primearr(int arr[], int size) {
    int* begin = arr;
    int* end = begin + size;

    std::vector<int> ret;

    while (begin < end) {
        if (*begin == 1)
            ret.push_back(begin - arr);
        ++begin;
    }

    return ret;
}

如果没有，请至少使用std::unique_ptr，以便您可以始终保持对数组的所有权，并且调用者不必担心手动取消分配数组：

std::unique_ptr<int[]> primearr(int arr[], int size, int& newarrsize) {
    int* begin = arr;
    int* end = begin + size;

    newarrsize = 0;
    while (begin < end) {
        if (*begin == 1)
            ++newarrsize;
        ++begin;
    }

    std::unique_ptr<int[]> newarray(new int[newarrsize]);
    // or, in C++14 and later:
    // auto newarray = std::make_unique<int[]>(newarrsize);

    int *ptr = newarray.get();
    begin = arr;
    while (begin < end) {
        if (*begin == 1) {
            *ptr = begin - arr;
            ++ptr;
        }
        ++begin;
    }

    return std::move(newarray);
}

使用指针返回新数组

1 个答案: