casting 相关问题

从函数调用函数

我有以下代码段，用于设置/格式化价格并获取从依赖项升级中重构的值。 我需要将值从表单传递到 amountOnBlur

字符串、wstring 和 u16string 之间的转换

我的C++模块从NodeJS（node-addon-api）接收一个JSON字符串，然后我使用rapidjson来处理数据，这需要const char*。 但是，对于某些功能（请参阅我之前的任务...

在 Polar 中流式传输时推断数据类型

我最近收到了一个大于内存的镶木地板文件，其中每一列都是字符串数据类型。我想做类型推断，将可以转换为整数和浮点数的列转换，并且

如何将整数转换为 std::u16string (C++11)？

没有方法 std::to_u16string(...)。显然 static_cast 似乎不是进行此类转换的最合适方法。 对于相反的转换，从字符串到整数，转换器可能是...

在 C# 中将 Task<T> 转换为 Task<object>，无需 T

我有一个充满扩展方法的静态类，其中每个方法都是异步的并返回一些值 - 像这样： 公共静态类 MyContextExtensions{ 公共静态异步任务 我有一个充满扩展方法的静态类，其中每个方法都是异步的并返回一些值 - 像这样： public static class MyContextExtensions{ public static async Task<bool> SomeFunction(this DbContext myContext){ bool output = false; //...doing stuff with myContext return output; } public static async Task<List<string>> SomeOtherFunction(this DbContext myContext){ List<string> output = new List<string>(); //...doing stuff with myContext return output; } } 我的目标是能够从另一个类中的单个方法调用这些方法中的任何一个，并将其结果作为对象返回。它看起来像这样： public class MyHub: Hub{ public async Task<object> InvokeContextExtension(string methodName){ using(var context = new DbContext()){ //This fails because of invalid cast return await (Task<object>)typeof(MyContextExtensions).GetMethod(methodName).Invoke(null, context); } } } 问题是转换失败。我的困境是我无法将任何类型参数传递给“InvokeContextExtension”方法，因为它是 SignalR 中心的一部分并且由 javascript 调用。在某种程度上，我不关心扩展方法的返回类型，因为它只会序列化为 JSON 并发送回 javascript 客户端。但是，我确实必须将 Invoke 返回的值转换为任务才能使用等待运算符。我必须为该“任务”提供一个通用参数，否则它将把返回类型视为 void。因此，这一切都归结为如何成功地将具有通用参数 T 的任务转换为具有对象通用参数的任务，其中 T 表示扩展方法的输出。 您可以分两步完成 - await使用基类执行任务，然后使用反射或dynamic收获结果： using(var context = new DbContext()) { // Get the task Task task = (Task)typeof(MyContextExtensions).GetMethod(methodName).Invoke(null, context); // Make sure it runs to completion await task.ConfigureAwait(false); // Harvest the result return (object)((dynamic)task).Result; } 这是一个完整的运行示例，它将上述通过反射调用 Task 的技术置于上下文中： class MainClass { public static void Main(string[] args) { var t1 = Task.Run(async () => Console.WriteLine(await Bar("Foo1"))); var t2 = Task.Run(async () => Console.WriteLine(await Bar("Foo2"))); Task.WaitAll(t1, t2); } public static async Task<object> Bar(string name) { Task t = (Task)typeof(MainClass).GetMethod(name).Invoke(null, new object[] { "bar" }); await t.ConfigureAwait(false); return (object)((dynamic)t).Result; } public static Task<string> Foo1(string s) { return Task.FromResult("hello"); } public static Task<bool> Foo2(string s) { return Task.FromResult(true); } } 一般来说，要将 Task<T> 转换为 Task<object>，我会简单地采用简单的连续映射： Task<T> yourTaskT; // .... Task<object> yourTaskObject = yourTaskT.ContinueWith(t => (object) t.Result); （文档链接在这里） 但是，您实际的具体需求是 通过反射调用 Task 并获取其（未知类型）结果 。 为此，您可以参考完整的dasblinkenlight的答案，它应该适合您的具体问题。 我想提供一个实现，恕我直言，这是早期答案的最佳组合： 精确的参数处理 无动态调度 通用扩展方法 给你： /// <summary> /// Casts a <see cref="Task"/> to a <see cref="Task{TResult}"/>. /// This method will throw an <see cref="InvalidCastException"/> if the specified task /// returns a value which is not identity-convertible to <typeparamref name="T"/>. /// </summary> public static async Task<T> Cast<T>(this Task task) { if (task == null) throw new ArgumentNullException(nameof(task)); if (!task.GetType().IsGenericType || task.GetType().GetGenericTypeDefinition() != typeof(Task<>)) throw new ArgumentException("An argument of type 'System.Threading.Tasks.Task`1' was expected"); await task.ConfigureAwait(false); object result = task.GetType().GetProperty(nameof(Task<object>.Result)).GetValue(task); return (T)result; } 您不能将 Task<T> 转换为 Task<object>，因为 Task<T> 不是协变的（也不是逆变的）。最简单的解决方案是使用更多反射： var task = (Task) mi.Invoke (obj, null) ; var result = task.GetType ().GetProperty ("Result").GetValue (task) ; 这很慢且效率低下，但如果不经常执行此代码则可用。顺便说一句，如果您要阻塞等待其结果，那么异步 MakeMyClass1 方法有什么用呢？ 另一种可能性是为此目的编写一个扩展方法： public static Task<object> Convert<T>(this Task<T> task) { TaskCompletionSource<object> res = new TaskCompletionSource<object>(); return task.ContinueWith(t => { if (t.IsCanceled) { res.TrySetCanceled(); } else if (t.IsFaulted) { res.TrySetException(t.Exception); } else { res.TrySetResult(t.Result); } return res.Task; } , TaskContinuationOptions.ExecuteSynchronously).Unwrap(); } 它是非阻塞解决方案，将保留任务的原始状态/异常。 最有效的方法是自定义等待者： struct TaskCast<TSource, TDestination> where TSource : TDestination { readonly Task<TSource> task; public TaskCast(Task<TSource> task) { this.task = task; } public Awaiter GetAwaiter() => new Awaiter(task); public struct Awaiter : System.Runtime.CompilerServices.INotifyCompletion { System.Runtime.CompilerServices.TaskAwaiter<TSource> awaiter; public Awaiter(Task<TSource> task) { awaiter = task.GetAwaiter(); } public bool IsCompleted => awaiter.IsCompleted; public TDestination GetResult() => awaiter.GetResult(); public void OnCompleted(Action continuation) => awaiter.OnCompleted(continuation); } } 具有以下用法： Task<...> someTask = ...; await TaskCast<..., object>(someTask); 这种方法的局限性在于结果不是 Task<object> 而是一个可等待的对象。 我根据dasblinkenlight的回答做了一个小小的扩展方法： public static class TaskExtension { public async static Task<T> Cast<T>(this Task task) { if (!task.GetType().IsGenericType) throw new InvalidOperationException(); await task.ConfigureAwait(false); // Harvest the result. Ugly but works return (T)((dynamic)task).Result; } } 用途： Task<Foo> task = ... Task<object> = task.Cast<object>(); 这样您就可以将 T 中的 Task<T> 更改为您想要的任何内容。 对于最佳方法，不使用反射和动态丑陋语法，也不传递泛型类型。我将使用两种扩展方法来实现这个目标。 public static async Task<object> CastToObject<T>([NotNull] this Task<T> task) { return await task.ConfigureAwait(false); } public static async Task<TResult> Cast<TResult>([NotNull] this Task<object> task) { return (TResult) await task.ConfigureAwait(false); } 用途： Task<T1> task ... Task<T2> task2 = task.CastToObject().Cast<T2>(); 这是我的第二种方法，但不推荐： public static async Task<TResult> Cast<TSource, TResult>([NotNull] this Task<TSource> task, TResult dummy = default) { return (TResult)(object) await task.ConfigureAwait(false); } 用途： Task<T1> task ... Task<T2> task2 = task.Cast((T2) default); // Or Task<T2> task2 = task.Cast<T1, T2>(); 这是我的第三种方法，但是不推荐：（类似于第二种） public static async Task<TResult> Cast<TSource, TResult>([NotNull] this Task<TSource> task, Type<TResult> type = null) { return (TResult)(object) await task.ConfigureAwait(false); } // Dummy type class public class Type<T> { } public static class TypeExtension { public static Type<T> ToGeneric<T>(this T source) { return new Type<T>(); } } 用途： Task<T1> task ... Task<T2> task2 = task.Cast(typeof(T2).ToGeneric()); // Or Task<T2> task2 = task.Cast<T1, T2>(); 将 await 与动态/反射调用混合使用并不是一个好主意，因为 await 是一条编译器指令，它会围绕调用的方法生成大量代码，并且使用更多反射来“模拟”编译器工作并没有真正的意义，延续、包装等 因为您需要的是在运行时管理代码，然后忘记在编译时工作的 asyc await 语法糖。重写 SomeFunction 和 SomeOtherFunction 而不使用它们，并在运行时创建的您自己的任务中开始操作。您将得到相同的行为，但代码非常清晰。

BigQuery - 使用 Left Join 和 Cast 函数更新表（语法错误：意外的关键字 CAST）

在 BigQuery 中，我尝试从另一个具有列“SB”的表 t2 更新表 t1 中具有所有空值的列“PSB”。问题出在进行左连接时的关键数据字段。数据...

Java泛型和instanceof

想知道如何使用 Java 泛型正确执行条件转换。 我的示例中的第一个castTo方法似乎是最明显的，但它给了我一个编译时错误A无法转换为T并且我

为什么此代码即使在强制转换时也会溢出？

我正在准备涉及 C 的考试，但即使在转换变量时我也会遇到变量错误。代码是从教授给我们的PowerPoint中复制的。 我正在经历...

com.google.gson.internal.LinkedTreeMap 无法转换为我的类[重复]

我在从 JSON 字符串获取对象时遇到一些问题。 我得到了产品类 公开课产品{ 私有字符串 mBarcode; 私有字符串 mName； 私有字符串 mPrice； ...

使用CAST将Varchar转换为Int时的获取和错误

我正在编写一个查询来计算出拍摄过多部电影的电影导演的数量。我已经获取了子查询的值，但是当我运行它时，我收到错误“转换失败，当

如何在 C++11 constexpr 中检查双精度位模式是否为 0x0？

我想检查给定的双精度/浮点变量是否具有实际的位模式 0x0。不要问为什么，它用在 Qt 中的一个函数（qIsNull()）中，我想将其设置为 constexpr。 原始代码使用了...

如何在 Java 中使用泛型类型参数内的附加边界进行强制转换

是否可以转换一个对象来适应既是泛型类型参数又具有多个边界的参数？ 我的情况如下： 公开 是否可以转换一个对象来适应既是泛型类型参数又具有多个边界的参数？ 我的情况是这样的： public <T extends TypeA & TypeB> void problematic(Class<T> class) { doSomething(); } public void myMethod(Object obj) { if (obj instanceof TypeA && obj instanceof TypeB) { problematic(obj.getClass()) } } 如果我有一个实现这两个接口的特定类，有问题的方法就可以正常工作。 问题是这一次，我只有一个对象可以使用，并且必须对其进行强制转换以满足编译器的要求。 有问题的方法已经被经常使用，我不想改变它。 我已经尝试过以下演员： problematic(obj.getClass()) problematic((Class<TypeA & TypeB>) obj.getClass()) problematic((Class<? extends TypeA & TypeB>) obj.getClass()) problematic((Class<?>) obj.getClass()) problematic((Class<(TypeA & TypeB)>) obj.getClass()) problematic((Class<TypeC>) obj.getClass()) TypeC 实现了 TypeA 和 TypeB，但该对象并未实际实现 TypeC，因此编译时它只是在运行时失败 原始类型 经过大量的试验和错误，我找到了使用原始类型的解决方案： problematic((Class) obj.getClass()) 这将给出 rawtypes 警告，但它有效，并且由于事先检查了强制转换，因此向强制转换添加 @SuppressWarnings("rawtypes") 没有真正的问题。 不过，这看起来更像是一种解决方法，我想知道为什么声明像 Class 这样的东西不是一个选项。

'is' 与带有 null 检查的尝试转换

我注意到 Resharper 建议我这样做： if（myObj.myProp 是 MyType） { ... } 进入这个： var myObjRef = myObj.myProp as MyType; if (myObjRef != null) { ... } 为什么会提示...

C++：将函数指针设置为具有更少/不同参数的函数

有没有一种方法可以将带有两个参数的函数指针设置为具有更少或不同参数的函数。 假设我有 双 func1(双 x); 我想要一个函数指针 双 (*f)(双...

Python 3 中 `int( x / y )` 和 `x // y` 之间的区别？

在Python中（可能是四舍五入），地板除法x // y与除法然后转换（例如int（x / y））之间是否有区别（如果有的话为什么？）？

将指向派生类的指针转换为引用指向基类的指针

为什么我无法将指向派生类的指针转换为引用指向基类的指针？ 结构基{}； 结构派生：基{}； int main() { 派生* 派生 = nullptr; 静态转换 为什么我无法将指向派生类的指针转换为引用指向基类的指针？ struct Base { }; struct Derived : Base { }; int main() { Derived* derived = nullptr; static_cast<Base*&>(derived); } 我得到： invalid static_cast from type 'Derived*' to type 'Base*&' 根据您的评论： “不，这不是一个学术问题。我需要调用一个以参数为参数的函数Base*&” 解决此问题的正确方法是创建一个适当类型的新指针变量，并将其（或者更确切地说，对其的引用）传递给相关函数： struct Base { }; struct Derived : Base { }; int main() { Derived* derived = nullptr; Base* base = static_cast<Base*>(derived); my_function(base); // takes a Base*& argument // If you need the pointer value and are sure that // it's a Derived* type: derived = static_cast<Derived*>(base); } 请注意，如果您在问题本身中包含相关信息（来自我上面引用的评论），您可能会更快收到此答案。 因为 Derived* 对象不是 Base* 对象，并且两者完全有可能具有不同的内存布局或值表示（例如，如果 Base 和 Derived 的对齐要求不同）。由于一个不是另一个，static_cast无法执行转换。 如果您知道自己在做什么并且知道类型双关语没问题，请使用类型双关语工具 — reinterpret_cast: reinterpret_cast<Base*&>(derived); 并注意误用的任何后果（与往常一样reinterpret_cast）。特别注意，根据 C++11 3.10/10，就标准而言，通过转换结果进行的任何访问都将是未定义行为（尽管您的编译器可能会提供更强的保证）。 请注意，在一般情况下，从 Derived* 到 Base* 的转换不必是无操作。例如，如果涉及多重继承，则可能涉及地址移位。 扩展https://stackoverflow.com/users/1782465/angew-is-no-longer-proud-of-so提供的答案，您可以尝试此代码来了解为什么引用 Base* （即Base*&) 无法绑定到 Derived*: struct B { int valb; }; struct D : B { int vald; }; template<typename T> struct SC { T vald_sc; }; template<typename T> struct MV { int valmv; T& valb; MV(T& vb) : valb(vb) {} }; void f1(B* dp) { } void f2(B*& dp) { } void f3(B** dp) { } int main() { SC<D> sc; MV<B> mv(sc.vald_sc); //Conversion succeeds because a D object is a B object: their memory layout starts at the same addr SC<D*> scp; //MV<B*> mvp(scp.vald_sc); //Error: candidate constructor not viable: no known conversion from 'D *' to 'B *&' for 1st argument //NB: A D* object is not a B* object. MV<B*> mvp1(reinterpret_cast<B*&>(scp.vald_sc)); MV<B*> mvp2(*reinterpret_cast<B**>(scp.vald_sc)); f1(scp.vald_sc); f2(reinterpret_cast<B*&>(scp.vald_sc)); f2(*reinterpret_cast<B**>(scp.vald_sc)); f3(reinterpret_cast<B**>(&scp.vald_sc)); return 0; } 仅针对您的错误 改变这个 static_cast<Base*&>(derived); to static_cast<Base*>(derived); ^^ 请参阅此处 http://ideone.com/1QuMLK 如果您想要参考，您需要做 Base* ptr = static_cast<Base*>(derived); Base &ref = *ptr; 你不能将指针转换为引用 - 它们是完全不同的东西

字符串转int时，如何判断是否会溢出？

我正在尝试将字符串转换为32位int，并且我想将小于-2^31的数字限制到-2^31，将大于2^31-1的数字限制到2^31-1。 到目前为止，这是我的代码，但由于某种原因，它不是

在 PSQL 中将字符串转换为十进制

我正在尝试使用以下命令将字符串转换为十进制： 选择强制转换（最低门票价格 AS DECIMAL(6,2) 来自所有_事件_详细信息 WHERE 最低票价 ~ E'^\d+$'; 但这并不

如何在 Swift 中转换闭包签名内的参数类型？

我正在尝试用 Swift（目前是 Swift 2）编写一个轻观察者类。这个想法是在实体组件系统中使用它，作为组件之间相互通信的一种手段，而无需

为什么禁止将 `int**const` 强制转换为 `const int**const`

以下内容是允许的： int * const p1 = nullptr; 自动 p2 = static_cast< const int * const >( ptr ); 根据我的理解，p1 是一个“const-ptr to int”，它被转换为 ...