类类似于一个函数对象? [英] class similar to a function object?
问题描述
假设我有一个数据结构(实际上它是图形),带有一个模板
参数(每个边和顶点的属性P):
struct graph< P> ;;
struct vertex< P> ;;
struct edge< P> ;;
我也有修改此数据结构的算法。算法的基本
大纲与属性类型无关。所以我
实现了算法的泛型版本和
的函数对象我需要的每种类型的属性。通过这种方式,添加一个新属性
只需要定义属性并实现函数
对象。这很好用,但我对
函数对象有疑问,它看起来或多或少是这样的:
模板< typename P>
struct function_object {
//初始化
void initialize(region< P>& r)const;
void initialize(edge< P>& e)const;
//评估
double evaluate(const edge< P>& e)const;
};
正如您所看到的,我使用模板参数声明了它(并且没有添加
实现)。对于每种类型的属性,我添加一个专门化(当然是
实现)。
struct my_property;
模板<>
struct function_object< my_property {
//初始化
void initialize(region< my_property>& r) const;
void initialize(edge< my_property>& e)const;
//评估
double evaluate(const edge< my_property> & e)const;
};
但我可以在不使用function_object的情况下完成此操作。
有针对此设计的专业人士和/或反对者吗?最初,我的想法是
只添加成员函数的专业化,而不是
全班,但这不起作用。
Suppose I have a datastructure (actually it''s a graph) with one template
parameter (the property P for each edge and vertex):
struct graph<P>;
struct vertex<P>;
struct edge<P>;
I also have an algorithm that modifies this datastructure. The basic
outline of the algorithm is independent of the type of property. So I
implemented a generic version of the algorithm and a function object for
each type of property I need. In this way, adding a new property
involves simply defining the property and implementing the function
object. And that works great, however I have a question about the
function object, which looks more or less like this:
template <typename P>
struct function_object {
// Initialization
void initialize(region<P>& r) const;
void initialize(edge<P>& e) const;
// Evaluation
double evaluate(const edge<P>& e) const;
};
As you can see I declared it with a template parameter (and add no
implementation). For each type of property I add a specialization (with
an implementation of course).
struct my_property;
template <>
struct function_object<my_property{
// Initialization
void initialize(region<my_property>& r) const;
void initialize(edge<my_property>& e) const;
// Evaluation
double evaluate(const edge<my_property>& e) const;
};
But I could as well have done this without using "function_object". Are
there pros and/or contras against this design? Initially, my idea was to
add only a specialization of the member functions only, and not the
whole class, but that doesn''t work.
推荐答案
Jef Driesen写道:
Jef Driesen wrote:
假设我有一个数据结构(实际上它是图表)使用一个
模板参数(每个边和顶点的属性P):
struct graph< P> ;;
struct vertex< P>;
struct edge< P> ;;
Suppose I have a datastructure (actually it''s a graph) with one
template parameter (the property P for each edge and vertex):
struct graph<P>;
struct vertex<P>;
struct edge<P>;
你的意思是,可能是
模板< class Pstruct graph;
template< class Pstruct vertex;
模板< class Pstruct edge;
You mean, probably
template<class Pstruct graph;
template<class Pstruct vertex;
template<class Pstruct edge;
我还有一个修改这个数据结构的算法。
I also have an algorithm that modifies this datastructure.
你的意思是,图形结构(和所有相关的)?
You mean, the graph struct (and all related)?
基本
算法的轮廓与属性的类型无关。所以我
为我需要的每种类型的属性实现了算法的泛型版本和函数对象
。通过这种方式,添加一个新属性
只需要定义属性并实现函数
对象。这很好用,但我对
函数对象有疑问,它看起来或多或少是这样的:
模板< typename P>
struct function_object {
//初始化
void initialize(region< P>& r)const;
void initialize(edge< P>& e)const;
//评估
double evaluate(const edge< P>& e)const;
};
正如您所看到的,我使用模板参数声明了它(并且没有添加
实现)。对于每种类型的属性,我添加一个专业化
(当然是实现)。
struct my_property;
模板<>
struct function_object< my_property {
//初始化
void initialize(region< my_property>& r) const;
void initialize(edge< my_property>& e)const;
//评估
double evaluate(const edge< my_property> & e)const;
};
但我可以在不使用function_object的情况下完成此操作。
是否有针对此设计的专业人士和/或反对者?最初,我的想法
只是仅添加成员函数的特化,并且
不是整个类,但这不起作用。
The basic
outline of the algorithm is independent of the type of property. So I
implemented a generic version of the algorithm and a function object
for each type of property I need. In this way, adding a new property
involves simply defining the property and implementing the function
object. And that works great, however I have a question about the
function object, which looks more or less like this:
template <typename P>
struct function_object {
// Initialization
void initialize(region<P>& r) const;
void initialize(edge<P>& e) const;
// Evaluation
double evaluate(const edge<P>& e) const;
};
As you can see I declared it with a template parameter (and add no
implementation). For each type of property I add a specialization
(with an implementation of course).
struct my_property;
template <>
struct function_object<my_property{
// Initialization
void initialize(region<my_property>& r) const;
void initialize(edge<my_property>& e) const;
// Evaluation
double evaluate(const edge<my_property>& e) const;
};
But I could as well have done this without using "function_object".
Are there pros and/or contras against this design? Initially, my idea
was to add only a specialization of the member functions only, and
not the whole class, but that doesn''t work.
什么行不通?
模板<>
void
function_object< my_property> :: initialize(region< my _property>& r)const
{
// blah
}
见常见问题5.8。
V
-
请在通过电子邮件回复时删除大写''A'
我没有回复最热门的回复,请不要问
What doesn''t work?
template<>
void
function_object<my_property>::initialize(region<my _property>& r) const
{
// blah
}
See FAQ 5.8.
V
--
Please remove capital ''A''s when replying by e-mail
I do not respond to top-posted replies, please don''t ask
>
Jef Driesen写道:
Jef Driesen wrote:
假设我有一个数据结构(实际上它是图表),带有一个模板
参数(每个边和顶点的属性P):
struct graph< P> ;;
struct vertex< P>;
结构边缘< P> ;;
Suppose I have a datastructure (actually it''s a graph) with one template
parameter (the property P for each edge and vertex):
struct graph<P>;
struct vertex<P>;
struct edge<P>;
不使用boost :: graph,然后。
Not using boost::graph, then.
我还有一个修改这个数据结构的算法。算法的基本
大纲与属性类型无关。所以我
实现了算法的泛型版本和
的函数对象我需要的每种类型的属性。
I also have an algorithm that modifies this datastructure. The basic
outline of the algorithm is independent of the type of property. So I
implemented a generic version of the algorithm and a function object for
each type of property I need.
函数对象和属性之间存在一对一的关系吗?
或者是否存在可以具有多个函数的属性
对象?
即sort算法接受每种类型的多个函数对象。
There is a one-to-one relation between function object and property?
Or are there properties for which you could have multiple function
objects?
I.e. the sort algorithm accepts multiple function objects per type.
我有一个关于函数对象的问题,如下所示:
模板< typename P>
struct function_object {
//初始化
void initialize(region< P>& r)const ;
void initialize(edge< P>& e)const;
//评估
double evaluate(const edge< P>& ; e)const;
};
I have a question about the function object, which looks like this:
template <typename P>
struct function_object {
// Initialization
void initialize(region<P>& r) const;
void initialize(edge<P>& e) const;
// Evaluation
double evaluate(const edge<P>& e) const;
};
通常,初始化是在构造函数中完成的。并且
评估
通常命名为operator()。您可能希望继承
std :: unary_function
以使其更兼容STL。
Usually initialization is done in the constructor, of course. And
evaluate
is usually named operator(). You might want to inherit from
std::unary_function
to make it more STL-compatible.
对于每种类型的属性,我都添加了一个带有实现的特化。
struct my_property;
template<>
struct function_object< my_property {
//初始化
void initialize(region< my_property>& r)const;
void initialize (edge< my_property>& e)const;
//评估
double evaluate(const edge< my_property>& e)const;
};
但我可以在不使用function_object的情况下完成此操作。
有针对此设计的专业人士和/或反对者吗?
For each type of property I add a specialization with an implementation.
struct my_property;
template <>
struct function_object<my_property{
// Initialization
void initialize(region<my_property>& r) const;
void initialize(edge<my_property>& e) const;
// Evaluation
double evaluate(const edge<my_property>& e) const;
};
But I could as well have done this without using "function_object". Are
there pros and/or contras against this design?
Pro:你可以使用function_object<将默认参数传递给
算法。
cf. std :: less< Tfor std :: sort。
Contra:它与STL或boost :: graph不兼容。
Pro: you can use function_object<Pas a default parameter to the
algorithm.
cf. std::less<Tfor std::sort.
Contra: it''s not compatible with STL or boost::graph.
最初,我的想法是只添加成员函数
的特化,而不是整个类,但这不起作用。
Initially, my idea was to add only a specialization of the member functions
only, and not the whole class, but that doesn''t work.
经常有效的简单解决方案:转发到免费功能模板,
specialize /
超载。
HTH,
Michiel Salters
Simple solution that often works: forward to a free function template,
specialize/
overload that.
HTH,
Michiel Salters
Victor Bazarov写道:
Victor Bazarov wrote:
Jef Driesen写道:
Jef Driesen wrote:
>假设我有一个数据结构(实际上它是一个图形)
模板参数(每个边和顶点的属性P):
结构图< P> ;;
struct vertex< P> ;;
struct edge< P> ;
>Suppose I have a datastructure (actually it''s a graph) with one
template parameter (the property P for each edge and vertex):
struct graph<P>;
struct vertex<P>;
struct edge<P>;
你的意思是,可能是
模板< class Pstruct graph;
template< class Pstruct顶点;
模板< class Pstruct edge;
You mean, probably
template<class Pstruct graph;
template<class Pstruct vertex;
template<class Pstruct edge;
当然。
Of course.
>我也有算法修改此数据结构。
>I also have an algorithm that modifies this datastructure.
你的意思是,图形结构(和所有相关的)?
You mean, the graph struct (and all related)?
这是正确的。
That is correct.
>基本
对象。这很有用,但我对
函数对象有疑问,它看起来或多或少是这样的:
模板< typename P>
struct function_object {
//初始化
void initialize(region< P>& r)const;
void initialize(edge< P>& e)const;
//评估
双重评估(const edge< P>& e)const;
};
正如您所看到的,我使用模板参数声明了它(并且没有添加
实现)。对于每种类型的属性,我添加一个专门化
(当然是实现)。
struct my_property;
template<>
struct function_object< my_property {
//初始化
void initialize(region< my_property>& r)const;
void initialize(edge< my_property>& e)const;
/ /评估
双重评估(const edge< my_property>& e)const;
};
但我可以在不使用function_object的情况下完成此任务。<是否有针对此设计的专业人士和/或反对者?最初,我的想法是仅添加成员函数的特化,而不是整个类,但这不起作用。
>The basic
outline of the algorithm is independent of the type of property. So I
implemented a generic version of the algorithm and a function object
for each type of property I need. In this way, adding a new property
involves simply defining the property and implementing the function
object. And that works great, however I have a question about the
function object, which looks more or less like this:
template <typename P>
struct function_object {
// Initialization
void initialize(region<P>& r) const;
void initialize(edge<P>& e) const;
// Evaluation
double evaluate(const edge<P>& e) const;
};
As you can see I declared it with a template parameter (and add no
implementation). For each type of property I add a specialization
(with an implementation of course).
struct my_property;
template <>
struct function_object<my_property{
// Initialization
void initialize(region<my_property>& r) const;
void initialize(edge<my_property>& e) const;
// Evaluation
double evaluate(const edge<my_property>& e) const;
};
But I could as well have done this without using "function_object".
Are there pros and/or contras against this design? Initially, my idea
was to add only a specialization of the member functions only, and
not the whole class, but that doesn''t work.
什么不起作用?
What doesn''t work?
仅提供初始化/评估函数的实现
(没有声明完整的类模板< struct
function_object< my_propertyabove)。因为我认为C ++语言不允许这样做,所以不可能为每种类型的属性添加不同的
成员变量。
模板<>
struct function_object< my_property1 {
int m_data; //假设我需要在这里注明
}
模板<>
struct function_object< my_property2 {
double m_data; //假设我需要双打
}
但那(或编写代码)不是我的主要问题(因为我是
已经有了它的工作。我想知道是否有一个优势超过
做这样的事情:
struct my_function_object {
//初始化
void initialize(region< my_property>& r)const;
void initialize(edge< my_property>& e)const;
//评估
双重评估(const edge< my_property>& e)const;
};
例如,在我的第一篇文章中没有使用模板化的function_object?
Providing only implementations for the initialize/evaluate functions
(without a declaring the full class template <struct
function_object<my_propertyabove). Because I think that is not allowed
by the C++ language and it will make it impossible to add different
member variables for each type of property.
template <>
struct function_object<my_property1{
int m_data; // suppose I need ints here
}
template <>
struct function_object<my_property2{
double m_data; // suppose I need doubles here
}
But that (or writing the code) was not my main problem (because i
already have it working. I was wondering if there is an advantage over
doing something like this:
struct my_function_object {
// Initialization
void initialize(region<my_property>& r) const;
void initialize(edge<my_property>& e) const;
// Evaluation
double evaluate(const edge<my_property>& e) const;
};
e.g., without using the templated "function_object" from my first post?
这篇关于类类似于一个函数对象?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!