C++ 在C+中使用模板时出错+；

我的模板是：

template <class T>
class Shape {
T val,val_new;
public:
Shape(T initval)
{
   val=initval;
}
T get()
{
   return val;
}
void set (T newval)
{
   val_new = newval;
}
void copy()
{
   val= val_new;
}
};

但也有错误：

In member function 'void Rectangle::actions()':
error: request for member 'plus' in '(((TwoPoint*)operator new(8u)), (((*<anonymous>)
<unknown operator> TwoPoint<T>::get() [with T=TwoPoint]()), <anonymous>))', which is of non-class type 'TwoPoint*'

成员函数“void Rectangle:：actions（）”中的

：
错误：在（（（两点*）运算符新（8u）），（（*）中请求成员“plus”
TwoPoint:：get（）[with T=TwoPoint]（），）”，属于非类类型“TwoPoint*”

还有一个错误：

In member function 'void Rectangle::actions()':
error: no pattern matching function for call to 'Shape<TwoPoint>::set(TwoPoint*)'
note: candidates are: void Shape<T>:: set<T> [with T=TwoPoint]

成员函数“void Rectangle:：actions（）”中的

：
错误：没有用于调用“Shape:：set（两点*）”的模式匹配函数
注：候选项为：void Shape:：set[带T=twoint]

由于相同的原因，在actions（）中执行类似操作时，还有两个错误。有人能解释一下这些错误以及如何改进它们吗？ 有什么方法可以提高代码的效率吗？

您有：

(new TwoPoint(val.get())).plus(1)

new

返回指向-

两点的指针，因此必须使用
->
而不是
来访问成员函数

但是如果你那样做了，在一般情况下，你会得到内存泄漏。我建议重新考虑您的设计，这样您就不需要动态分配东西了。
您有：

(new TwoPoint(val.get())).plus(1)

new
返回指向-
两点的指针，因此必须使用
->
而不是
来访问成员函数

但是如果你那样做了，在一般情况下，你会得到内存泄漏。我建议重新考虑您的设计，这样您就不需要动态分配东西。
Shape:：set
按值获取其参数，但您正在使用
new
创建一个值并传递一个指针。除非实际需要动态对象，否则应避免使用
new
；在这种情况下，您需要确保在完成后将其删除

在这种情况下，您只需要按值传递对象：

 void actions()
 { 
   if (load_called)
       val.set(newval);
   if(incr_called && !decr_called)
       val.set(val.get().plus(1));
   if(!incr_called && decr_called)
       val.set(val.get().plus(-1));
 }     

有什么方法可以提高代码的效率吗

动态分配通常比使用自动对象效率低——修复错误也消除了效率低下的根源

Shape:：set
，构造函数可以引用它们的参数，
Shape:：get
可以返回引用，以避免不必要的复制；尽管在实践中，编译器可能会避免这些副本。此外，构造函数可以使用初始化器列表直接初始化成员，而不是默认地初始化它们并重新分配它们。在某些情况下，这样的代码可能会稍微更有效：

Shape(T const & initval)      // pass by reference
  : val(initval)              // use initialiser list
{}
T const & get()               // return by reference
{
   return val;
}
void set (T const & newval)   // pass by reference
{
   val_new = newval;
}

但总的来说，重点是使代码正确可读，并选择有效的算法；只有当小的低效被证明是一个瓶颈时，才需要担心它们。
Shape:：set
按值获取其参数，但您正在使用
new
创建一个值并传递一个指针。除非实际需要动态对象，否则应避免使用
new
；在这种情况下，您需要确保在完成后将其删除

在这种情况下，您只需要按值传递对象：

 void actions()
 { 
   if (load_called)
       val.set(newval);
   if(incr_called && !decr_called)
       val.set(val.get().plus(1));
   if(!incr_called && decr_called)
       val.set(val.get().plus(-1));
 }     

有什么方法可以提高代码的效率吗

动态分配通常比使用自动对象效率低——修复错误也消除了效率低下的根源

Shape:：set
，构造函数可以引用它们的参数，
Shape:：get
可以返回引用，以避免不必要的复制；尽管在实践中，编译器可能会避免这些副本。此外，构造函数可以使用初始化器列表直接初始化成员，而不是默认地初始化它们并重新分配它们。在某些情况下，这样的代码可能会稍微更有效：

Shape(T const & initval)      // pass by reference
  : val(initval)              // use initialiser list
{}
T const & get()               // return by reference
{
   return val;
}
void set (T const & newval)   // pass by reference
{
   val_new = newval;
}

但总的来说，重点是使代码正确可读，并选择有效的算法；只有当小的效率低下被证明是一个瓶颈时，才需要担心。
新的
操作员是明显的罪魁祸首。使用自动变量可以解决内存泄漏问题。当像Shape和TwoPoint这样的类可以作为引用而不是通过复制的值传递时，代码会得到进一步的改进。我承认自己有点无聊，对代码也有点费劲，甚至用ostream添加调试输出。不过，我无法帮助您了解应用程序的逻辑。我不知道为什么会有某些构造，所以我保留了它们的大部分（除了val_new，因为目前它没有向代码中添加任何内容）

我希望在进一步开发此应用程序时，这些调试内容会证明是有用的。
新的
操作员显然是罪魁祸首。使用自动变量可以解决内存泄漏问题。当像Shape和TwoPoint这样的类可以作为引用而不是通过复制的值传递时，代码会得到进一步的改进。我承认自己有点无聊，对代码也有点费劲，甚至用ostream添加调试输出。不过，我无法帮助您了解应用程序的逻辑。我不知道为什么会有某些构造，所以我保留了它们的大部分（除了val_new，因为目前它没有向代码中添加任何内容）

我希望在进一步开发此应用程序时，这些调试内容会很有用。
我不理解内存泄漏part@user：您正在动态分配一个对象，但从未删除过该对象。@用户：请先更正代码。那么，在确定这是一个问题后，请担心效率。我不理解内存泄漏part@user：您正在动态分配一个对象，但从未删除过该对象。@用户：请先更正代码。一旦你确定这是一个问题，那么就要担心效率。
Creating a Rectangle using TwoPoint( 800, 300 )
Rectangle( Shape( TwoPoint( 800, 300 ) ) )
Rectangle( Shape( TwoPoint( 800, 300 ) ), load_called )
Rectangle( Shape( TwoPoint( 100, 200 ) ) )
Rectangle( Shape( TwoPoint( 100, 200 ) ), incr_called )
Rectangle( Shape( TwoPoint( 101, 200 ) ) )
Rectangle( Shape( TwoPoint( 101, 200 ) ), decr_called )
Rectangle( Shape( TwoPoint( 100, 200 ) ) )