Question

我遇到了以下问题：

“编写一个模板函数vectorMAXMIN（），它将接受一个向量和一个表示向量大小的数字，并将返回向量的最大值和最小值”......

所以我想在其中...创建一个类向量，以避免“大小”传递值并控制插入，并可以从中获取最大值和最小值...（不知道如果这是一个好主意）

问题是“如何返回一个元组？”当我读到这个问题时，我认为在元组中返回“最大值，最小值”是否正确？

代码：

#include <iostream>

template < typename T >
class _tuple
{
    public:
        T _Max;
        T _Min;
};

template < typename T >
class _vector
{
    public:
        _vector( int cnt = 0);
        ~_vector();
        _tuple< T > get_tuple( void );
        void insert( const T );
    private:
        T *ptr;
        int cnt;
        int MAX;
};

template < typename T >
_vector< T >::_vector( int N )
{
    ptr = new T [N] ; 
    MAX = N;
    cnt = 0;
}

template < typename T >
_tuple<T> _vector< T >::get_tuple( void )
{
    _tuple< T > _mytuple;
    _mytuple._Max = ptr[0];
    _mytuple._Min = ptr[0];
    for( int i = 1; i < cnt; i++)
    {
        if( _mytuple._Max > ptr[i]  )
            _mytuple._Max = ptr[i];
        if( _mytuple._Min < ptr[i] )
            _mytuple._Min = ptr[i];
    }
    return _mytuple;
}   

template < typename T >
void _vector< T >::insert( const T element)
{
    if( cnt == MAX )
        std::cerr << "Error: Out of range!" << std::endl;
    else
    {
        ptr[cnt] = element;
        cnt++;
    }
}

template < typename T >
_vector< T >::~_vector()
{
    delete [] ptr;
}

int main()
{
    _vector< int > v;
    _tuple < int > t;
    v.insert(2);
    v.insert(1);
    v.insert(5);
    v.insert(0);
    v.insert(4);
    t = v.get_tuple();
    std::cout << "MAX:" << t._Max;
    std::cout << " MIN:" << t._Min;
    return 0;
}

Answer 1

我会使用std::pair来返回最小值和最大值。

另外，如果你在C ++中这样做，你可能想要使用std::vector实现而不是自己开发的实现，只需“扫描”传入的std::vector一次而不是实现你的自己的矢量。虽然，问题的读法，你可能希望传入一个数组和数组大小。

Answer 2

对于最近的编译器，通常不需要模拟元组，对于您的特定用例而言根本不需要。对于您的用例 - 两个值的元组 - std::pair非常合适（正如James McNellis所提到的）。对于两个或更多值的元组，TR1提供std::tr1::tuple，C ++ 0x提供std::tuple。

编辑：对于缺乏TR1或C ++ 0x支持的旧编译器，当然有boost来拯救 - 特别参见boost.tuple和boost.fusion。

Answer 3

或者只使用std::pair。

Answer 4

@Timo Geusch ...我正在阅读更多内容并且我编码...你觉得它是否正确？：

#include <iostream>
#include <vector>
#include <utility>

using namespace std;

int main()
{
    int a[] = {1,6,5,-1};
    vector< int > v( a, a+4 );
    pair < int, int > _tuple( *v.begin(), *v.begin() ); // < MAX, MIN >
    for( vector< int >::iterator it = v.begin() + 1; it != v.end(); it++ )
    {
        if( _tuple.first > *it )
            _tuple.first = *it;
        if( _tuple.second < *it )
            _tuple.second = *it;
    }
    cout << "MAX:" << _tuple.first << endl;
    cout << "MIN:" << _tuple.second << endl;
    return 0;
}

C ++问题解决 - 它是模拟“元组”的最佳方式吗？

4 个答案: