关于原语:当我从小类型转换到大类型时,转换是隐式的,当我从大类型转换到小类型时,我需要显式地转换原语,这显然是由于数据丢失造成的。但有件事我不明白。在某些情况下,当我向上或向下转换为字符(字节和短)时,我总是需要在两个方向显式地转换,虽然字节(8位)适合字符(16位)?
(另见)
看看我的例子..。
public class CastingTest
{
public static void main(String[] args)
{
//casting from smaller to bigger types
short c = 13;
在Java中,假设我有3个类,C由B扩展而来,B从A扩展而来。
class X {
interface A {}
interface B extends A {}
interface C extends B {}
void f(A a) {}
void test() {
C c = new C()
B b = (B) c;
f(b);
}
}
如果我这样做,如上面的test()所示:
C c = new C()
B b = (B) c;
f(b);
f()接受b作为C类型,因为C和B都是从A扩展而来。我希望f()将b
使用Linq,我想返回一个包含客户和发票的对象。
我理解从方法返回单个类型:
public IQueryable<customers> GetCustomers()
{
return from c in customers
select c;
}
但是我很难弄清楚多个对象:
public IQueryable<???> GetCustomersWithInvoices()
{
return from c in customers
from inv in c.invoices
select
我在试着做简单的数学运算。a=5,b=a/2 &(向上舍入),当我向上舍入时,它必须是5/2 = 3,c= b -a,3-5=2。我的问题是,当我除以5/2并向上舍入时,B得到2而不是3。有人能帮助我如何向上取整得到3吗?谢谢
int a=5;
int b=(int)Math.ceil(a/2);
int c=b-a;
System.out.println(b);
System.out.println(c);
根据
当将参数传递给对象类型上的方法时,将自动应用向上转换。但是,对于模块中的let绑定函数,除非参数类型声明为灵活的类型,否则向上转换不是自动的。
但
type C() =
member this.T() = ()
type D() =
inherit C()
let myfun (x: C)=
()
let d = D()
myfun d
我根本不需要上床。
如果:
interface I{}
class A implements I{}
class B extends A{}
class C extends B{}
A a = new A();
B b = new B();
Why a = (B)(I)b; is correct
but b = (B)(I)a; is false?
我发现投射非常令人困惑,如果我可以向下投射或向上投射对象,最好的方法是什么?
协方差和向上转换之间的区别是什么,或者更具体地说,为什么它们被赋予不同的名称?
我看过下面这个被称为“向上转换”的例子:
string s = "hello";
object o = s; //upcast to 'string' to 'object'
然而,我见过的以下情况称为“协方差”:
string[] s = new string[100];
object[] o = s;
IEnumerable<string> ies = new List<string>();
IEnumerable<object&
有什么问题:
let (x:UIElement) = upcast new TextBlock()
错误是:这里需要类型'System.ComponentModel.ISupportInitialize‘,并且不可用。必须添加对程序集'System,Version=4.0.0.‘的引用。
TextBlock是UIElement的一个亚型.
请注意,执行错误消息所述的操作确实解决了问题,但为什么这是必要的,以做一些基本的事情,如向上转换?
假设我有一种类似algol的语言,带有静态类型和下面的代码:
a := b + c * d;
其中a是浮点数,b是整数,c是双,d是长。然后,该语言将d转换为long以使用c,将b转换为double以处理c*d结果。因此,在此之后,b+c*d的双重结果将转换为浮动,以将结果分配给a。但是,当发生这种情况时,我的意思是,所有的转换都是在运行时还是编译时发生的?
如果我有:
int x; //READ FROM USER KEYBOARD.
if (x > 5) {
a:= b + c * d;
}
else {
a := b + c;
}
上面的代码有条件项。如果编译器在编
我在这个网站上读了一些其他的帖子,它们提到dynamic_cast和static_cast都可以安全地向上转换。
为什么这些是向上转换所必需的?
例如,如果B类派生自A,则
A * ptr = new B ();
仍然有效,并且行为类似于类型A的对象。(我也来自Java背景,在那里向上转换是不必要的。
我还在这个网站上读到,向下转换不需要dynamic_cast [问题是""]。同样,我认为只有当你向下转换时才真正有必要进行转换,因为向上转换是自动发生的。
我哪里错了?
我试图用GCC 6编译一些相当简单的C++代码,但是得到了一个缩小转换警告。这是有问题的,因为我们将警告视为错误。
struct S {
short int a;
short int b;
};
short int getFoo();
short int getBar();
std::array<S, 2> arr = {{
{5, getFoo()},
{3, getFoo() + getBar()} // Narrowing conversion here?
}};
您可以在上看到这段代码正在运行。GCC说,getFoo() + getB
我有一段代码可以在C中工作,但不能在C++中工作,有没有办法让它在C和C++上都能工作呢?
void foo(void* b)
{
int *c = b;
printf("%d\n",*c);
}
int main ()
{
int a = 1000;
foo(&a);
return 0;
}
输出:
C++:
1 In function 'void foo(void*)':
2 Line 3: error: invalid conversion from 'void*' to 'int*'
3
我有以下使用reactive扩展的代码片段:
let value : 't = ...
Observable.Create<'t>(fun observer ->
let subject = new BehaviorSubject<'t>(value)
let d0 = subject.Subscribe(observer)
let d1 = observable.Subscribe(subject)
new CompositeDisposable(d0, d
我可能误解了explicit的说明符。但是为什么下面的代码要编译呢?
struct A {
};
struct B : A {
};
struct C {
A* a_;
explicit C(A* a) : a_(a) { }
};
int main() {
B b;
C c(&b);
}
基类C构造函数使用隐式向上转换为A*的B*调用。我认为explicit说明符的目的是防止参数的隐式转换?
我之所以问这个问题,是因为我理解向单个参数构造函数添加explicit说明符是一种很好的做法,我想检查我的编译器是否允许我做一些我不应该做的事情。
我有一个类型为response['additional-info']的字段string。它的结构是一个json。
"{"supported-tags":[{"s1":"someS1","s2":"someS2","s3":"someS3"}]}"
我想转换一些类型的B。
B是
export class C{
constructor(
public s1:string,
public s2:string,
public s3:
所以我有一个openCL程序,其中一些变量在float2中,一些变量在double2中。我想对这些变量进行向上转换或向下转换,但我不确定该怎么做。我试图显式地转换它,就像我通常对float和double所做的那样,但它不起作用。
float2 a,b;
double2 c,d;
a = (float2)(c+d); //didnt work
a = float2(c+d); //didnt work
也许我不理解类型"float2“和"double2",有人能告诉我如何转换它们才能正常工作吗?
提前谢谢。
虽然我可以将字符串向上转换为对象,但不能将字符串的IList向上转换为对象的IList。怎么会这样?除了将所有项目复制到新的IList之外,现在还能做什么?
static void ThisWorks()
{
IList<object> list = new List<object>();
list.Add("I can add a string since string : object");
}
static void ThisDoesNotWork()
{
// throws an invalid cast exce
最近我在F#中尝试了一些自动向上转换的可能性,我知道F#强制要明确,但我注意到在某些情况下确实存在向上转换。
下面是一些代码,显示了向上转换工作和不工作的情况:
type NameValue(name: string, value: obj) = class end
type GenNameValue<'T>(name: string, value: 'T) = class end
type MoreNameValue<'Name, 'Value>(name: 'Name, value: 'Value) = class e