我目前正在开发一个应用程序,我需要从SQL数据库加载数据,然后将检索到的值分配给对象的属性.我这样做是通过使用反射,因为属性名称和列名称是相同的.但是,许多属性都使用自定义结构类型,它基本上是十进制类型的货币包装器.我在我的struct中定义了一个隐式转换:
public static implicit operator Currency(decimal d)
{
return new Currency(d);
}
Run Code Online (Sandbox Code Playgroud)
我在代码中使用它时工作正常.但是,当我有这个:
foreach (PropertyInfo p in props)
{
p.SetValue(this, table.Rows[0][p.Name], null);
}
Run Code Online (Sandbox Code Playgroud)
它抛出一个ArgumentException,声明它无法从System.Decimal转换为Currency.我很困惑,因为它在任何其他情况下都能正常工作.
例如,我需要在函数中访问清单def a[A:ClassManifest]以获取擦除类.我可以使用Predef.implicitly函数,但在这种情况下,我的代码将与我使用完整形式一样长def a[A](implicit b:ClassManifest[A]).那些隐式参数是否有方便的生成名称?
#include <iostream>
struct Int {
int i;
operator int() const noexcept {return i;}
};
int main() {
Int i;
i.i = 1;
std::cout << i;
}
Run Code Online (Sandbox Code Playgroud)
但是,这无法在GCC 4.8.1上编译:
#include <iostream>
#include <string>
struct String {
std::string s;
operator std::string() const {return s;}
};
int main() {
String s;
s.s = "hi";
std::cout << s;
}
Run Code Online (Sandbox Code Playgroud)
以下是错误的相关部分:
错误:'operator <<'不匹配(操作数类型是'std :: ostream {aka std :: basic_ostream}'和'String')
std :: cout << s;SNIP
template std :: basic_ostream <_CharT,_Traits>&std :: …
检查下面的代码:
class Money
{
public Money(decimal amount)
{
Amount = amount;
}
public decimal Amount { get; set; }
public static implicit operator decimal(Money money)
{
return money.Amount;
}
public static explicit operator int(Money money)
{
return (int)money.Amount;
}
}
Run Code Online (Sandbox Code Playgroud)
我不明白它在我的代码中会有用,我不能只做一个像这样的方法:
public static int returnIntValueFrom(Money money)
{
return (int)money.Amount;
}
Run Code Online (Sandbox Code Playgroud)
实施不是更容易和更清楚吗?
以下代码工作正常:
#include <iostream>
struct B
{
operator int()
{
return int();
}
};
struct A
{
A(int, int){ std::cout << "A(int, int)" << std::endl; }
};
A a({B(), B()});
int main()
{
}
Run Code Online (Sandbox Code Playgroud)
并产生输出:
A(int, int)
Run Code Online (Sandbox Code Playgroud)
但我不明白为什么?标准说的是:
但是,当考虑构造函数或用户定义的转换函数的参数时,如果在类复制初始化的第二步中复制/移动临时函数时,通过13.3.1.3调用该函数,则通过13.3.1.7传递时初始化程序列表作为单个参数,或者当初始化程序列表只有一个元素并且转换为某个类X或引用(可能是cv限定的)时,X仅被视为X [...]的构造函数的第一个参数考虑标准转换序列和省略号转换序列
所以在我们的例子中,我们考虑了构造函数的参数(它是{B(), B()}).更确切地说,我们将initializer-list作为单个参数传递(我引用的规则中的第二个案例).现在,我们需要将initializer-list的第一个元素(临时类型B)转换为int,并且唯一的方法是应用用户定义的convertion(B::operator int()).但是,正如在规则末尾所说的那样,我只引用标准转换序列和省略号转换序列.因为,该代码不起作用,它应该抛出A(int, int)不可行或类似的错误.
怎么了.可能是一个错误?
我想摆脱对一个generic(asInstanceOf[A])的运行时强制转换而不进行隐式转换.
当我有一个相当干净的数据模型,包含具有共同特征的案例类并希望在其上实现通用算法时,就会发生这种情况.作为一个例子,生成的算法应该采用一个类的类A,它是一个子类,trait T并且应该返回A具有一些更新字段的具体类的副本.
当我可以简单地将一个abstract copy-method 添加到基本特征并在所有子类中实现它时,这很容易实现.然而,这可能会使用某些算法仅需要的方法来污染模型,有时不可能,因为模型可能不受我的控制.
下面是一个演示问题的简化示例和使用运行时强制转换的解决方案.
请不要挂断细节.
假设有一个特征和一些我不能改变的案例类:
trait Share {
def absolute: Int
}
case class CommonShare(
issuedOn: String,
absolute: Int,
percentOfCompany: Float)
extends Share
case class PreferredShare(
issuedOn: String,
absolute: Int,
percentOfCompany: Float)
extends Share
Run Code Online (Sandbox Code Playgroud)
这是一种percentOfCompany在股票总数发生变化时重新计算当前流量的简单方法,并更新案例类中的字段
def recalculateShare[A <: Share](share: A, currentTotalShares: Int): A = {
def copyOfShareWith(newPercentage: Float) = {
share match {
case common: CommonShare => common.copy(percentOfCompany = newPercentage)
case preferred: PreferredShare => preferred.copy(percentOfCompany …Run Code Online (Sandbox Code Playgroud) #include <stdio.h>
int main() {
printf("sizeof(int): %zu\n", sizeof(int));
printf("%d\n", 2147483648u > -2147483648);
printf("%d\n", ((unsigned int)2147483648u) > ((int)-2147483648));
printf("%d\n", 2147483648u != -2147483648);
printf("%d\n", ((unsigned int)2147483648u) != ((int)-2147483648));
return 0;
}
Run Code Online (Sandbox Code Playgroud)
在C和C++中,在cygwin64和带有gcc 5.2.0的rhel6.4机器上输出此代码是:
sizeof(int): 4
1
0
1
0
Run Code Online (Sandbox Code Playgroud)
根据" 整数促销 ",2147483648u将是类型unsigned int(即使没有u后缀)和-2147483648类型int(像往常一样).为什么显式铸造的结果不同?
根据" 常用算术转换 ",本段适用:
否则,签名是不同的:如果具有无符号类型的操作数的转换等级大于或等于带符号操作数的类型的等级,则带有签名类型的操作数将隐式转换为无符号类型
这意味着正确的结果就像:
2147483648u > 2147483648u
2147483648u != 2147483648u
Run Code Online (Sandbox Code Playgroud)
执行,因为在32位中,带符号-2 ^ 31和无符号2 ^ 31具有相同的表示.换句话说,铸造的结果是正确的.到底是怎么回事?
我感觉不知何故,在没有强制转换的情况下应用了更高级别的整数提升,所以我在双方都获得了例如64位签名促销 - 但为什么呢?
这两个可执行文件都编译为64位,这可以发挥作用吗?
我喜欢C#的一个原因是你可以为你的类定义隐式转换器.例如,我创建了一个VectorGeometryBuilder具有类似方法类MoveForwardByX,TurnByYDegrees,LineToPoint等,然后定义的隐式转换到一个Geometry类.这允许我使用我漂亮的构建器来创建我的几何,然后只需将整个kit-n-caboodle传递给任何期望a的函数Geometry,即使它VectorGeometryBuilder本身不是子类Geometry.而是它将一个Geometry对象暴露为一个属性,这是隐含的转换器抓住并返回.
我想知道的是Swift是否有类似的东西.
考虑这个构成的场景......
class FauxInt
{
init(_ initialValue:Int)
{
value = initialValue
}
var value:Int
}
let fauxInt = FauxInt(14)
Run Code Online (Sandbox Code Playgroud)
这些是我想要做的事情......
let realInt:Int = fauxInt
someFuncTakingAnInt(someInt:fauxInt)
Run Code Online (Sandbox Code Playgroud)
同样,转换到Int应该是隐含的意思是任何期望的Int,我可以使用或传递一个FauxInt代替.
有没有办法让上述成为可能?
假设我们有一个泛型类的想法Matrix<T>哪里T是数字型(Complex或double或者float,int等).
很自然,我们在C#中从in float到doublefrom double进行了隐式转换Complex.一般规则是我们有从较小类型到较大类型的隐式转换.到现在为止还挺好.
现在假设我们正在实现我们的Matrix<T>类型.由于这种新型的方式是数字也(或者至少其持有的数值),这是很自然有隐式转换从Matrix<float>到Matrix<double>,从Matrix<double>对Matrix<Complex>等至少它是好的,有这些像乘数学运算,加等但是这似乎无法正确实现,因为隐式运算符要求至少一个类型与我们实现它的类相同.
示例:下面的代码无法编译,甚至认为它可以解决我的问题.
public abstract partial class Matrix<T>
{
/// <summary>
/// Implicitly converts a matrix to double precision complex numbers.
/// </summary>
public static implicit operator Matrix<Complex64>(Matrix<double> matrix)
{
matrix.ToComplex();
}
/// <summary>
/// Implicitly converts a matrix to double precision real numbers.
/// </summary>
public static implicit …Run Code Online (Sandbox Code Playgroud) 我被一个生产错误所困,我把一个不纯的0元函数传递给了一个错误地期望一个裸结果类型的类.
def impureFunc(): Future[Any] = ???
case class MyService(impureDependency: Future[Any] /* should have been () => Future[Any] */)
Run Code Online (Sandbox Code Playgroud)
实际上,这会MyService立即调用impureFunc并缓存程序生命周期的第一个结果,从而导致一个非常微妙的错误.
通常,类型系统会阻止这类错误,但由于能够在没有参数列表的情况下调用0-ary函数,编译器会接受此程序.
显然,这是Scala的"功能",旨在使代码看起来更干净,但这是一个糟糕的问题.有没有办法使这成为编译器警告或linting错误?换句话说,不赞成"空应用程序"类型的隐式方法转换?