Question

我不知何外是模板的新手，我正在尝试修改一些为c ++提供矩阵和向量操作的库，我有一个向量类，我试图重载operator（）来处理一个操作像这样Vector（2：5）会返回一个包含原始向量元素2,3,4,5的向量，我正在使用一个名为冒号的类，冒号（2：5）代表（2：5））因为我发现c ++没有运算符：。希望我给出了适当的介绍。相关代码如下

Vector Class

template< size_t M, typename T = float >
class Vector
{
public:
typedef T   value_type;
inline T& operator()( size_t index );
inline const T& operator()( size_t index ) const;
template <size_t N> Vector<N,T> operator()(const  colon &cex) const;
.
.
}

和相应的实现

template< size_t M, typename T >
template< size_t N>
Vector<N,T>
Vector<M,T>::operator()( const colon &cex ) const
{
long i, ii, st = 0, in = 0, en = 0, s;
cex.apply(M, st, in, en, s);
if (s && (st>0) && (st>M))
{
Vector<N,T> result;
for (i=st,ii=0;i+=in,ii++;i<=en,ii<N)
{
result(ii)=array(i);
return result;
}

}
return 0;
}

这里的返回0只是一个占位符，它应该返回一个空向量。冒号类（取自另一个库并由我修改）。

class colon
{
public:
/// Colon expression '(:)'
colon() { _flag = 'a'; }
/// Colon expression of type '(2:5)'
colon(long s, long e) { _s = s; _i = 1; _e = e; _flag = 'r'; }
void apply(long s, long &f, long &i, long &l, long &n) const;

private:
/// Type of colon expression.
char _flag;
/// First index.
long _s;
/// Increment.
long _i;
/// Last index.
long _e;

}; /* class colon */

并且相关的实施是

void
colon::apply(long n, long &st, long &in, long &en,
     long &le) const
{
switch (_flag)
{
    case 'r':
        if ((_i == 0 ) || ((_e - _s) / _i < 0 )) le = 0;
        else
        {
            st = _s;
            in = _i;
            en = _e - (_e - _s) % _i;
            le = (_e - _s) / _i + 1;
        }
        break;
    case 'a':
        if (n)
        {
            st = 1;
            in = 1;
            en = n;
            le = n;
        }
        else le = 0;
        break;

 }
}

用于测试功能的代码是

bool ok = true;

Vector< 4, double > v;
double data[] = { 1, 2, 3, 4 };

v.iter_set( data, data+4 );//just puts elements of data inside v with the same type

// test  Vector colon
{
    bool ok = true;
    Vector<3,long> test;
    test=v(colon(2,4));//Problem

}

现在的错误是

C2664: 'const double &Vector<M,T>::operator ()(size_t) const' : 
cannot convert parameter 1 from 'colon' to 'size_t'

编译器的输出是

error C2664: 'const double &Vector<M,T>::operator ()(size_t) const' : 
cannot convert parameter 1 from 'colon' to 'size_t'
with
[
M=4,
T=double
]
No user-defined-conversion operator available that can perform this conversion, 
or the operator cannot be called

????感谢帮助

Answer 1

template <size_t N> Vector<N,T> operator()(const  colon &cex) const;

本身是在N上模板化的，N的值不能从冒号中推导出来，所以在重载集中不会考虑它。

Answer 2

我有太多话要说不适合评论，所以我会用这个答案（虽然它没有直接回答你的问题）：

你需要知道你的用例是什么。如果您要对运行时变量做很多事情，那么在模板中实现它就没有任何意义。如果您只想使用模板，那么您也需要使用class colon。我会给你一些提示。

首先让我比评论所说的更详细地解释你的问题。

假设我们有一个Vector<5, int> vec;，可以看一些用例。

案例“编译时大小”：

//get the entries with indices 1 to 3 (including)
Vector<3, int> vec2 = vec(colon(1, 3));

对于这段代码，所有内容在编译时都是已知的，因此可以在编译时执行此操作（尽管为此目的没有必要的丑陋）。

案例“运行时大小”：

//we get the variables a and b as input from the user at runtime
Vector<?, int> vec2 = vec(colon(a, b));

查看a和b个变量？你在编写程序时知道它们的价值吗？不，你不能，因为用户应该输入它们。它们可以是0:0或0:4或42:1337，他们知道用户将进入的内容（意外）。当您不知道a和b的值时，您也不知道?会有什么，但您必须在编译时知道，因为每个模板参数都有在编译时知道。

现在您需要知道自己想做什么。您想使用a:b（运行时参数）还是只想输入1:3等常量（编译时参数）。根据这一点，您需要选择，如何实施Vector<n,T>::operator()。

您会看到：Vector的大小一旦取决于运行时值，就无法在编译时确定，因此无法返回正确大小的向量。

然而，您可以实现编译时大小和运行时大小的向量和冒号类，以便以更复杂的实现为代价来实现这两者。他们会给出以下模式：

CompileTimeVector CompileTimeVector::operator()(CompileTimeColon);
RunTimeVector CompileTimeVector::operator()(RunTimeColon);
RunTimeVector RunTimeVector::operator()(CompileTimeColon);
RunTimeVector RunTimeVector::operator()(RunTimeColon);

这种模式对于任何操作在Vector和冒号的运行时和编译时类型之间进行互操作是必要的。

类模板上的重载方法，编译器看不到它，只看到其他重载函数

2 个答案: