我正在尝试创建一个子类的TForm
这是我现在的代码:
interface
TfrmEndoscopistSearch = class(TForm)
public
/// original constructor kept for compatibility
constructor Create(AOwner : TComponent); overload; override;
/// additional constructor allows for a caller-defined base data set
constructor Create(AOwner : TComponent; ADataSet : TDataSet; ACaption : string = ''); overload;
end;
它似乎工作,但我总是得到编译器警告:
[Warning] test.pas(44): Method 'Create' hides virtual method of base type 'TCustomForm'
是否有可能创建一个只接受字符串文字的构造函数(或函数签名),而不是例如char const *？
是否有可能有两个可以区分字符串文字的重载char const *？
C++ 0x会允许使用自定义后缀 - 但我正在寻找"早期"解决方案.
基本原理:避免在作为字符串文字给出时不会被修改的字符串的堆副本.
这些字符串直接转到API,期望const char *没有任何处理.大多数调用确实使用不需要额外处理的文字,只在少数情况下构建它们.我正在寻找保留原生呼叫行为的可能性.
注意: - 因为它出现在答案中:有问题的代码根本不使用std::string,但一个很好的例子是:
class foo
{
std::string m_str;
char const * m_cstr;
public:
foo(<string literal> s) : m_cstr(p) {}
foo(char const * s) : m_str(s) { m_cstr = s.c_str(); }
foo(std::string const & s) : m_str(s) { m_cstr = s.c_str(); }
operator char const *() const { return m_cstr; }
}
结果:
(1)不能做到.
(2)我意识到我甚至不是在寻找一个文字,而是一个编译时常量(即"任何不需要复制的东西").
我可能会使用以下模式: …
可能重复:有
什么合理的理由使一元运算符超载？
我刚看了这个问题,我不禁想知道:
为什么有人可能想要重载&("address-of")运算符？
some_class* operator&() const { return address_of_object; }
有没有合法的用例？
考虑假设的对象层次结构,从以下开始:
TFruit = class(TObject)
public
constructor Create(Color: TColor); virtual;
end;
及其后代:
TApple = class(TFruit)
public
constructor Create(); overload; virtual;
constructor Create(Color: TColor); overload; override; //deprecated. Calls other constructor - maintaining the virtual constructor chain
end;
这里的想法是我已经覆盖了基类的虚构造函数,其重载也恰好是虚拟的.
德尔福抱怨:
方法'Create'隐藏基类型'TFruit'的虚方法
除了它不隐藏它 - 它就在那里!
这是怎么回事？
我想将一个自定义对象数组传递给一个String.Join具有以下签名的函数:
public static string Join(string separator, params Object[] values)public static string Join(string separator, IEnumerable<T> values)如果我这样调用函数:
var arr = new MyClass[]{ new MyClass(), new MyClass() };
string text = string.Join("\n", arr);
我收到编译器错误:
以下方法或属性之间的调用不明确:'string.Join(string,params object [])'和'string.Join(string,System.Collections.Generic.IEnumerable)'
我可以通过使用IEnumerable<T>函数来解决歧义:
var arr = new MyClass[]{ new MyClass(), new MyClass() };
string text = string.Join<MyClass>("\n", arr);
但是我可以调用该params object[]函数吗？在性能关键的情况下,最好是直接访问数组而不是通过枚举器.
我正在使用C#4.0,如果这有任何区别.
为什么这段代码有效:
template<
typename T,
std::enable_if_t<std::is_same<T, int>::value, T>* = nullptr>
void Add(T) {}
template<
typename T,
std::enable_if_t<!std::is_same<T, int>::value, T>* = nullptr>
void Add(T) {}
并且可以正确区分这两个调用:
Add(1);
Add(1.0);
而以下代码如果编译导致重新定义Add()错误？
template<
typename T,
typename = typename std::enable_if<std::is_same<T, int>::value, T>::type>
void Add(T) {}
template<
typename T,
typename = typename std::enable_if<!std::is_same<T, int>::value, T>::type>
void Add(T) {}
所以如果模板参数是类型,那么我们就重新定义了函数,如果它是非类型的,那么一切都好.
我有这个代码:
def setVelocity (x, y, yaw)
setVelocity (Command2d.new(x,y,yaw))
end
def setVelocity (vel)
......
end
vel是一个Command2D类,有3个属性,可比较和定义+,基本上是一个方便的类来管理这3个属性,所以我想在我的库内部使用它(不想让它们变成私有的,要么给它们奇怪的名字).但是,即使参数数量不同,Ruby似乎也只保留最后一个setVelocity.所以当我用3个参数调用setVelocity时会说我只需要用一个参数调用该方法.
我已经实现了以下界面:
template <typename T>
class Variable
{
public:
Variable (T v) : m_value (v) {}
virtual void Callback () = 0;
private:
T m_value;
};
一个适当的派生类将定义如下:
class Derived : public Variable<int>
{
public:
Derived (int v) : Variable<int> (v) {}
void Callback () {}
};
但是,我想派生Callback接受不同参数的类(例如:void Callback (int a, int b)).有没有办法做到这一点？
前几天我注意到这一点,说你有两个重载方法:
public void Print<T>(IEnumerable<T> items) {
Console.WriteLine("IEnumerable T");
}
public void Print<T>(T item) {
Console.WriteLine("Single T");
}
这段代码:
public void TestMethod() {
var persons = new[] {
new Person { Name = "Yan", Age = 28 },
new Person { Name = "Yinan", Age = 28 }
};
Print(persons);
Print(persons.ToList());
}
打印:
Single T
Single T
在这些情况下,为什么Person[]和他们相比List<Person>更好？TIEnumerable<T>
谢谢,
更新: 此外,如果你有另一个重载
public void Print<T>(List<T> items) {
Console.WriteLine("List T");
}
Print(persons.ToList());实际上会打印List T而不是Single …
例如,如果我有一个结构FooSpec:
struct FooSpec { /* lots of data */ };
将以下两个都作为重载函数提供是不好的做法吗？或者我应该选择一个并坚持下去？
Foo *createFoo(const FooSpec *spec) { /* ... */ }
Foo *createFoo(const FooSpec &spec) { return createFoo(&spec); }
两者都会导致意想不到的问题？