常量 T * 搜索 ( 常量 T &) 返回不起作用

const T * search ( const T &) return not working

本文关键字：常量 返回 不起作用 搜索      更新时间：2023-10-16

我有这个问题，我的程序在开始使用这个函数后崩溃。我不知道如何正确地返回所需的类型。它是在模板中进行二进制搜索。我尝试将其更改为T*search，将array[middle]强制转换为const，并执行类似const T * out = &array[middle];的操作，但每当我添加&，它崩溃了。如果我把它拿走，只返回数组[中间]，它会说：

cannot convert 'Fractions' to 'const Fractions*' in return

我应该如何正确返回？我有这样声明的数组，这个函数在同一个类中：它应该适用于任何类型，我们得到了类Fractions来测试它，所以它是Fractions类型的普通数组，没有什么奇怪的。

   T * array;

和

   const T *search(const T &inElement){

    unsigned low = 0;
    unsigned high = numberOfElements-1;
    unsigned middle = 0;
    while(low <= high){
        middle = low + (high - low)/2;
        if( inElement == array[middle]){
            const T * out = &array[middle]; //problem here
            return out;
        }
        else if(inElement < array[middle]){
          high = middle -1;
        }
        else{
           low = middle + 1;
        }

    }
    return NULL;
}

指针和引用对我来说一直是个问题，我读过关于向量的类似主题，但仍然无法理解

我班的其他同学：

#include <iostream>
#include "Fractions.cpp"
using namespace std;


template<class T,unsigned n>
class SortedArray {
T * array;
unsigned length;
unsigned numberOfElements;
T element;
unsigned position;

public:
SortedArray() {
    length = n;
    array = new T[n];
    numberOfElements = 0;
    position = 0;
}

bool first(){
    if(numberOfElements >= 1){
        element = array[0];
        position = 0;
        return true;
    }
    return false;
}
bool next(){
 if(position+1 < numberofElements){
  position++;
  element = array[position];
  return true;
 }
 return false;
}
const T & aktual(){
 return element;
}

SortedArray & operator << (const T &element){

    if(numberOfElements == length || search(element) == NULL){return (*this);}
    if(numberOfElements == length){return (*this);}
    int i = numberOfElements;
    for (; i > 0 && array[i-1] > element; i--)
    {
        array[i] = array[i-1];
    }
    array[i] = element;
    numberOfElements++;
    return (*this);
}

operator unsigned () const{
return numberOfElements;
}

const T *search(const T &inElement){
//this is the function causing problems
}


~SortedArray() {
    delete [] array;
    array = NULL;
}


};

int main()
{
    SortedArray<Fractions,20> pz;
    typedef Fractions Z;
    pz << Z(1,3) << Z(3,5) << Z(7,4) << Z(3,4) << Z(2,3) << Z(7,2)
     << Z(5,4) << Z(1,4) << Z(6,7) << Z(4,3) << Z(2,3);

    cout << "nNumber of elements : " << pz.operator unsigned() << endl;
    return 0;
}

当numberOfElements为0时，您的函数将失败。你有一条线：

unsigned high = numberOfElements-1;

当numberOfElements为0时，high将接收广播给unsigned int的值-1，这是一个非常大的数字。这将导致对数组的访问超出其末尾，这是未定义的行为，并且经常会崩溃。

关于你关于return声明的问题，你现在所掌握的是正确的。

相关文章：