不能为类型'GenericTableViewController<GenericTableViewCell<_>，_>分配类型'GenericTableViewController<T，U>‘的值
这个错误信息是一个编译错误，它表示无法将类型为'GenericTableViewController<GenericTableViewCell<>, >'的值分配给类型'GenericTableViewController<T, U>'。这个错误通常发生在泛型编程中，当尝试将一个具有不同类型参数的泛型对象赋值给另一个泛型对象时。
要解决这个错误，需要检查代码中涉及到的泛型类型和对象的声明和使用。以下是一些可能的解决方法：
- 确保泛型类型参数的一致性：检查代码中涉及到的泛型类型参数，确保它们在声明和使用时是一致的。如果类型参数不一致，可能需要调整代码逻辑或重新设计泛型类。
- 使用类型约束：如果泛型类型参数需要满足特定的条件，可以使用类型约束来限制参数的类型。通过使用类型约束，可以确保泛型类型参数在不同的地方使用时具有相同的类型。
- 检查泛型对象的实例化：如果在代码中创建了泛型对象的实例，确保实例化时传入的类型参数是一致的。如果类型参数不一致，可能需要调整实例化代码。
- 检查泛型对象的方法和属性：如果在代码中使用了泛型对象的方法和属性，确保它们在不同的地方使用时具有相同的类型参数。如果类型参数不一致，可能需要调整方法和属性的定义或调用方式。
总之，要解决这个错误，需要仔细检查代码中涉及到的泛型类型和对象的声明和使用，并确保它们在不同的地方使用时具有相同的类型参数。根据具体的代码和上下文，可能需要进行适当的调整和修改。
相关·内容
1回答
在以下使用xtensor的函数中，我期望编译器将计算图表示为auto z = 3.0 * u + 100 * xt::cos(u);，并在xt::xtensor_fixed<T, xt::xshape<nn>> out = z;将表达式赋值给精确的张量时计算结果。
template<typename T, size_t nn>
T func_cos(xt::xtensor_fixed<T, xt::xshape<nn>> &u) {
auto z = 3.0 * u;
for (auto k = 0; k &
浏览 7提问于2020-10-10得票数 1
回答已采纳
1回答
模板动态分配
、、、
我创建了一个包含两个模板变量的类Vector，我试图构建这样一个字典来告诉特定学生的标记。问题是我很难用模板动态分配内存。我必须在没有地图或STL帮助的情况下做这个。你能解释一下，如何正确地分配它们。
#define DEF_CAPACITY 20
template <class U, class T>
class Vector {
protected:
T* _data;
U* _keys;
int _size; //size in use
int _capacity; //available capacity
public:
//cons
浏览 1提问于2021-06-21得票数 0
回答已采纳
2回答
希望将泛型类型空值转换为“0”。我编写了以下代码，尝试在设置后临时来回转换，但是当值为null时得到一个异常.
IEvaluateService Create<T>(
string compareOperator,
T value,
...)
{
value ??= (T)Convert.ChangeType("0", typeof(T));
}
例外：System.InvalidCastException: Invalid cast from 'System.String
浏览 10提问于2022-05-10得票数 -1
1回答
我写了一个查询包的驱动代码。但我有蓝屏问题，我也去了垃圾堆。在分析之后，我在下面提到的特定行上得到了错误。为什么会出现这个错误？我可以查看unsigned char pointer with zero吗？
我的定义：
typedef unsigned char u8_t ;
typedef unsigned char s8_t ;
typedef unsigned short u16_t ;
我的函数
void function1 (u8_t ntype , u16_t nvar , u8_t *pbuffer)
{
HEADER packet = (HEADER)allocatemry
浏览 0提问于2015-10-07得票数 0
注:学习严格的混叠规则。请耐心等待。
代码示例(t935.c)：
#include <stdio.h>
int f(int* pi, double* pd)
{
*pi = 13;
*pd = 7E-323;
return *pi;
}
int main(void)
{
union { int i; double d; } u;
printf("%d\n", f(&u.i, &u.d));
return 0;
}
请求：
$ gcc t935.c -Wall -Wextra -std=c11 -pe
浏览 6提问于2021-09-01得票数 3
回答已采纳
在TypeScript中，可调用类型之间的关系有以下问题：
type CheckExtends<T, U> = T extends U ? T : never
type NumberFunc = (op: number) => number
type AnyFunc = (op: any) => any;
type UnknownFunc = (op: unknown) => any;
type NumberAny = CheckExtends<NumberFunc, AnyFunc> // NumberFunc
type NumberUnknow
浏览 5提问于2020-03-28得票数 3
回答已采纳
1回答
考虑以下简化和不完整的固定大小向量的实现：
template<typename T>
class Vec {
T *start, *end;
public:
T& operator[](ssize_t idx) { return start[idx]; }
void pop() {
end--;
end->~T();
}
template<typename... U>
void push(U... args) {
new (end) T { std::forward<U>(args)...
浏览 3提问于2016-10-20得票数 11
我有以下代码：
type T = { foo: string }
var t: T = { foo: 'foo' }
interface S { foo: string }
var s: S = t
所以我们知道T < S。
这个怎么样？
t = s
好的，所以S < T也是真的。
我们可以暗示S == T。
现在介绍U
type U = { [key: string]: string }
var u: U = t
所以T < U。到目前一切尚好。
但是等等！
u = s // Error!
这似乎违反了Liskov替代原则：
如果S是T的一个子类型，那么
浏览 2提问于2019-10-05得票数 1
回答已采纳
我在TypeScript的第二天，所以这可能是一个重复的问题(因为我可能不知道该搜索什么)。
我正在尝试做一些基本的FP练习来熟悉TypeScript。这里我有一个带有构造函数的标准反列表类型：
type ConsList<T> =
null |
[T, ConsList<T>]
function cons<T>(head: T, tail: ConsList<T>): ConsList<T> {
return [head, tail];
}
function fromArray<T>(arr:
浏览 3提问于2021-09-01得票数 0
回答已采纳
2回答
管理琐碎类型
、、、、
我已经在C++中发现了一些复杂的琐碎类型，可以理解并希望有人能在以下方面对我有所启发。
给定T类型，使用::operator new(std::size_t)、::operator new[](std::size_t)或std::aligned_storage分配T的存储，以及指向该存储中的位置的void * p，该位置适合于T，以便可以在p上构造
如果std::is_trivially_default_constructible<T>::value有效，那么当代码在p跳过T的初始化(即通过使用T * tPtr = new (p) T();)时，代码是否调用了未定义的行为，然后
浏览 4提问于2017-02-17得票数 18
回答已采纳
我很难用仿制药。首先我宣布
public class SymmetricIndexedRealMatrix<T> implements iIndexedMatrix<T,T, Double>{
public Double getElement(T rowObject, T columnObject) { ... }
}
然后
public class CRF<U> {
private SymmetricIndexedRealMatrix<U> binaryEnergy;
private Set<U> label
浏览 0提问于2015-02-22得票数 2
回答已采纳
1回答
，但是当使用索引签名对象类型时，答案不起作用。例如：
type UniqueObject<T, U> = { [K in keyof U]: K extends keyof T ? never : U[K] }
export function mergeUnique <T, U, V> (
a: T,
b?: UniqueObject<T, U>,
c?: UniqueObject<T & U, V>,
) {
return {
...a,
...b,
...c,
}
}
type Obj
浏览 0提问于2020-01-10得票数 1
回答已采纳
3回答
我试图重写这样的通用代码(C#)：
U Upcast<T, U>(T x) where T : U { return x; }
在F#中：
let ucast<'T, 'U when 'T :> 'U> (x: 'T) = x :> 'U
但是F#约束解决方法与C#不同，编译器输出大量类型错误：
error FS0698:无效约束:用于约束的类型是密封的，这意味着约束只能由一种解决方案来满足。
警告FS0064:此构造导致代码不像类型注释所指示的那样泛型。类型变量'T‘被限制为’U‘类型。
error
浏览 4提问于2010-12-30得票数 7
回答已采纳
1回答
转换结构指针到联合指针
、、、、
我有一个包含各种兼容的union成员的struct：
enum Type { T1, T2, … };
struct S1 { enum Type type; … };
struct S2 { enum Type type; … };
…
union U {
enum Type type;
struct S1 as_s1;
struct S2 as_s2;
…
};
这些结构的type字段被视为不可变，并且只访问与当前type对应的联合字段。我知道，只要维护union U *不变量，就可以将type转换为struct S1 *，但反过来也是正确的吗？
str
浏览 2提问于2016-10-09得票数 3
回答已采纳
1回答
C++内存分配操作符的形式为operator new (size_t s)。当我为T类型的类对象重载new操作符时，它是否保证操作符new的输入参数(即size_t s)恰好为sizeof(T)？如果是，为什么这个函数仍然需要size作为输入参数？
浏览 1提问于2015-12-18得票数 12
我有一些类似于这些接口的接口，在这些接口中，我以后要排除的接口只包含可选属性：
interface P {
id: string
}
interface A extends P {
attrA: string
}
interface B extends P {
attrB?: string
}
现在，将此接口从与其他接口的联合中排除在外是行不通的：
type R = Exclude<A | B, B> // expected: A, is: never
类型R是never，但应该是A。
我可以看到，如果Exclude<T, U> = T ex
浏览 0提问于2019-07-24得票数 3
回答已采纳
我试图将输入限制为一个对象，但它失败了：
showModal<T extends {[key: string]: any}, U>(component: Type<AbstractDialogComponent<T, U>>,
options?: ModalDialogOptions & { context: T }): Observable<U> {
options = { context: {}, viewContainerRef: this.vcRef,
fullscreen: true , ...
浏览 0提问于2018-06-20得票数 0
回答已采纳
2回答
template<typename T, typename U = int>
struct A {};
template<typename T, typename U>
struct A<T*, U> {};
template<typename T, typename U>
struct A<T[], U> {};
int main()
{
A<int*> m; // m: A<int*, int>
A<int[]> n; // n: A<int[], int>
浏览 1提问于2020-10-19得票数 0
回答已采纳
2回答
我有以下代码：
interface IConverter<T, U>
{
U Convert(T obj);
}
interface IBusinessEntityConveter<T, U> : IConverter<T, U>
where U : BusinessEntity
{
}
class LookupConveter<B> : IBusinessEntityConveter<Lookup, B>, IConverter<Lookup, Moniker>
where B : Busin
浏览 3提问于2010-10-18得票数 2
回答已采纳
你好，我正在尝试将一个元素从一个列表(在示例foo中) (end()-1)转移到另一个列表(在名为bar的示例中)，以定位begin()。
唯一的问题是其中一个列表使用自定义的分配器。这可能会导致以下错误消息：
../src/TestAllocator.cpp:120:28: error:
no matching function for call to
‘std::list<int>::splice ( std::_List_iterator<int>&,
std::list<int, Cu
浏览 4提问于2017-09-05得票数 0
回答已采纳
我对C++内存管理非常陌生，但我想亲手构建一个简单的分配器，为一些容器预先分配足够的内存。
我看过Alexandrescu库，并试图阅读一些博客，但所有这些对我来说都很难理解。我想从一些原始的和工作的起点开始，扩展它，看看它是如何发展的。这是我现在所拥有的，也是我所理解的(我的起点)：
template <class T>
struct Allocator {
Allocator(){};
template <class U>
Allocator(Allocator<U> const&);
T* allocate
浏览 0提问于2018-01-02得票数 6
2回答
我正在编写一个Arena Allocator，它可以工作，但我觉得它违反了严格的别名规则。我想知道我是对还是错。以下是代码的相关部分：
typedef struct ArenaNode ArenaNode;
struct ArenaNode {
ArenaNode *next;
size_t dataSize;
u8 data[];
};
typedef struct {
ArenaNode *head;
ArenaNode *current;
size_t currentIndex;
} Arena;
static ArenaNode *A
浏览 4提问于2019-02-15得票数 4
当我运行这段代码时：
type Converter<T extends ConverterOutput> = (value: string) => T
type ConverterOutput = number | string
function generateConverter<T extends ConverterOutput>(
value: string,
type: 'number' | 'string'
): Converter<T> {
return (value: string): T =
浏览 0提问于2018-11-20得票数 1
回答已采纳
1回答
是否可以在C++中的基本类型之间提供自定义的隐式转换？
具体地说，我有一个Xerces-c库，它包含：
using XMLCh = unsigned short int;
但是当然，没有办法将文字字符串作为unsigned short int提供。所以我想要像这样的：
operator unsigned short int*(char16_t* s) { return reinterpret_cast<unsigned short int*>(s); }
operator char16_t*(unsigned short int* s) { return reinterpret_c
浏览 2提问于2014-09-19得票数 1
我有以下代码：
#include <iostream>
using namespace std;
template <class T> class Foo {
public:
template <class U> void operator = (const U &u) {
cout << "generic copy assigment\n";
}
void operator = (const Foo<T> &f) {
cout <<
浏览 2提问于2010-11-05得票数 3
回答已采纳
我有一些代码，如下所示。我为我的钩子定义的自定义类型返回编写带有泛型类型的自定义钩子。
type Return<T> = [T, (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void, Record<keyof T, boolean>, () => void]
function useInput<T>(): Return<T> {
const [input, setInput] = useState<T>({} as T);
浏览 28提问于2020-02-14得票数 1
回答已采纳
我的问题基本上是跟进：
基本上，尽管C++11标准现在允许有状态分配器，但我们仍然有这样的要求:如果您复制某个Allocator，则该副本必须通过==运算符与原始值进行比较。这表明副本可以安全地释放原来分配的内存，反之亦然。
因此，这已经禁止分配器保持唯一的内部状态，比如块分配器或内存池之类的。一种解决方案是对内部状态使用shared_ptr指针到实现的成语，这样一些原始Allocator的所有副本都使用相同的底层内存池。这还不算太糟。除了..。
根据上面提到的问题以及公认的答案，标准似乎还要求Allocator<T>与Allocator<U>具有一个可互操作的副本构
浏览 6提问于2014-12-14得票数 12
回答已采纳
5回答
我看到了以下代码：
class Sample<T,U> where T:class where U: struct, T
在上述情况下，参数U是值类型，它来自引用类型T。
这条线怎么可能合法？
另外，如果值类型从引用类型继承，那么内存在哪里分配:堆还是堆栈？
浏览 3提问于2009-02-24得票数 4
回答已采纳
1回答
我用C语言编写了一个程序来计算矩阵的SVD，使用Jacobi的算法。我在程序中有三个函数:一个叫做jacobi_helper的函数，它将执行SVD，一个叫做jacobi的函数，它在初始化几个数组之后调用jacobi_helper，以及主函数调用jacobi。
我的问题在于，在jacobi_helper中，似乎正确地执行了SVD，但是这些值似乎没有返回到jacobi，即使它们是在一个空函数中传递的。最后，我试图打印SVD的矩阵U和V，以及奇异值的向量。我的困惑是，奇异值的向量能够很好地打印，但矩阵不能打印。
这是我的代码：
#include <stdio.h>
#in
浏览 3提问于2015-03-07得票数 0
回答已采纳
3回答
考虑以下类结构：
public class Foo<T>
{
public virtual void DoSomething()
{
}
public class Bar<U> where U : Foo<T>, new()
{
public void Test()
{
var blah = new U();
blah.DoSomething();
}
}
}
public class Baz
{
}
publ
浏览 3提问于2011-10-28得票数 6
回答已采纳
我在玩类型记录，并试图看看我是否能够创建一个Either类型的概念来表示成功和失败的路径。我创建了一个用户定义的类型保护，通过使用符号显式地缩小成功/失败的类型。我不知道为什么either在isFailure分支中的值显示为Data & CustomError的交集类型，而不是CustomError。
const FailureSymbol = Symbol('Failure');
interface IFailure {
symbol: Symbol;
}
type Success<T> = T
type Failure<T extend
浏览 0提问于2018-04-21得票数 0
回答已采纳
3回答
如何使下列扩展工作？我将ComboBoxe绑定到枚举，在本例中它不编译，因为它返回null。
public static T GetSelectedValue<T>(this ComboBox control)
{
if (control.SelectedValue == null)
return null;
return (T)control.SelectedValue;
}
注意:我希望它返回null (而不是默认值(T))。问题是，我要在哪里使用的表达式是什么？
浏览 0提问于2011-09-04得票数 7
回答已采纳
2回答
我正在把Nat Pryce的Maybe课程翻译成Delphi。
以下是一些背景：
大部分都很容易但是..。
如何将这个声明从Java转换成Delphi?
public abstract <U> Maybe<U> to(Function<? super T, ? extends U> mapping);
它是一个抽象的虚拟函数&to，它使用名为mapping的function作为参数，但我不知道如何对其建模。
对于上下文，下面是完整的代码：
package com.natpryce.maybe;
import com.google.common.ba
浏览 5提问于2013-10-03得票数 2
回答已采纳
1回答
我刚刚完成了一个关于重写操作符new和delete的个人项目，并在这个过程中了解了分配程序类。在阅读了包括cppreference.com在内的多个在线参考之后，我注意到许多函数被描述为可选函数。
我的问题是，如果接收到的分配器仅可选地实现函数和类型，那么分配器接收方(例如std::set )如何工作？
我会理解，如果分配器需要从具有所有函数默认实现的某个基类派生，但似乎不需要对分配器进行继承。
或者，通过编译错误来实现这些可选函数的必要性是否会引起人们的注意呢？
作为参考，这里是我第一次尝试一个分配器，我使用它作为std::set的第三个模板参数。我研究了一个现有的例子，所以我相信我已经实现
浏览 7提问于2016-09-09得票数 1
回答已采纳
我有一个类似于以下内容的类：
class FooClassAnalyser<T extends Foo> extends ClassAnalyser<T>
(其中ClassAnalyser是许多具体实现的抽象基类；FooClassAnalyser是专门针对T扩展Foo的具体实现)。它有一个构造函数，如下所示：
FooClassAnalyser(Class<T> classToAnalyse)
在另一个类中，我有一个用于ClassAnalyser的静态工厂方法，它根据classToAnalyse的类型调用适当的构造函数。
static <U> Cl
浏览 3提问于2017-06-12得票数 5
我目前正在编写一个Vulkan呈现器，我刚刚意识到我应该只接受属于repr(C)的类型，但据我所知，在编译时无法实际检查这些类型。
struct Vertex {
x: f32,
y: f32,
b: Box<f32>
}
#[repr(C)]
struct Vertex2 {
x: f32,
y: f32,
b: Box<f32>
}
fn to_bytes<T>(t: &T) -> &[u8]{
let p: *const T = t;
let p = p as *
浏览 3提问于2017-03-16得票数 13
回答已采纳
std::allocator的construct和destroy成员函数根据要构造的元素的类型进行参数化：
template<class T>
class allocator
{
public:
typedef T value_type;
typedef T* pointer;
template<class U, class... Args>
void construct(U *p, Args&&... args);
template<class U>
void destro
浏览 0提问于2012-05-11得票数 8
回答已采纳
2回答
下面是作用域保护的惯用C++11实现，它在作用域退出时还原值？
template<typename T>
class ValueScopeGuard
{
public:
template<typename U>
ValueScopeGuard(T& value, U&& newValue):
_valuePtr(&value),
_oldValue(std::forward<U>(newValue))
{
using std::swap;
浏览 2提问于2014-03-26得票数 2
回答已采纳
2回答
我在球拍中定义了以下类型：
(define-type vname (Pairof String Integer))
(define-type term (U vname (Listof (Pairof String term))))
(define-type subst (Listof (Pairof vname term)))
我如何定义一个以t是vname类型还是(Listof (Pairof String term))类型为条件的带有签名(-> subst term term)的过程(lift s t)？有没有一种简单的方法来测试联合类型的实际类型？如果我有(define-ty
浏览 7提问于2017-05-10得票数 0
1回答
一对多实体框架错误
、、、、
我有两个型号，用户和电话。用户可以有许多电话号码。
我的用户代码：
public class User
{
public User()
{
this.TelephoneNumbers = new List<Telephone>();
}
public int UserId { get; set; }
public string Forename { get; set; }
public string Surname { get; set; }
public string Firs
浏览 3提问于2015-03-12得票数 0
回答已采纳
2回答
我有以下抽象基类定义为：
public abstract class BaseObject<T> : IComparable, IComparable<T>, IEquatable<T> {}
我还有一个接口定义为：
public interface ICode<T> where T : struct
{
T Code { get; }
}
现在，我想派生一个从BaseObject<T>继承并包含接口ICode<T>的类。
我试着这样定义它：
public class DerivedObject<T, U&g
浏览 3提问于2010-12-31得票数 1
回答已采纳
1回答
我有C函数，它调用指针到函数(指针指向buf和buf的大小)
printf("------------------------------\n");
printf("lengh of DATA_output = %zu\n", p->tot_len);
(*myStr.OnSendData)(buf, p->tot_len);
printf("------------------------------\n");
指向定义如下的函数的指针
typedef void (*pOnSendData)(void *buf, u16_t len
浏览 1提问于2014-07-28得票数 0
回答已采纳
1回答
我想概括一下这里描述的情况：
因此，我将有一个类似于下面(genericFunction)的函数，在这个函数中，我还不知道obj类型，但是我想确保obj[key]只能是特定类型的。
/// https://stackoverflow.com/a/58880555/4233401
type Identical<T, TTest, TTrue, TFalse> = (<U extends T>(
o: U
) => void) extends <U extends TTest>(o: U) => void
? TTrue
: TFal
浏览 0提问于2020-10-23得票数 0
回答已采纳
我有一个返回<DataContract> Public Class Character的服务。该类具有一个属性<DataMember> Public Property Modifiers As ModernList(Of Modifier)。修饰符也是一个DataContract :这里的问题是ModernList。ModernList(Of T)是我对列表的实现，并作了一些修改；它来自System.Collections.Generic.List(Of T)。现在，我知道在WCF中返回派生类时，我们应该用<KnownType>来修饰基类，但是，我不能用它来
浏览 1提问于2014-12-13得票数 0
我正在阅读下面的代码
#[inline]
pub fn plane<T: Component>(&self, index: usize) -> &[T] {
if index >= self.planes() {
panic!("out of bounds");
}
if !<T as Component>::is_valid(self.format()) {
正如您所看到的，plane函数返回一个泛型类型的片段。这是否意味着我需要总是像这样调用这个函数：plane::<Some
浏览 0提问于2020-10-07得票数 0
编辑:我现在已经完全修正了我的代码。下面是：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
int main(){
int n, i , j;
char **mensagem;
char leitura[1000];
FILE *arquivo;
arquivo = fopen("entrada.txt", "r");
fgets(leitura, 100
浏览 2提问于2013-01-16得票数 1
回答已采纳
2回答
可能重复：
#include <stdlib.h>
int main(int argc, const char *argv[])
{
char *b=(char*)malloc(sizeof(char)*50);
b=(char*)"hello world";
// works
char a[50];
a=(char*)"hello world";
//doesn't work. why? I thought array names are just pointers that poin
浏览 4提问于2012-06-06得票数 3
回答已采纳
2回答
我需要一种方法来获取类或类型的任何属性的类型。
例如，如果我有PersonClass和PersonType，我想得到nationalId类型。我可以这么做：
class PersonClass{
name: string
nationalId: number
}
type PersonalType={
name: string
nationalId: string
}
type GetNationalIdType<T> = T extends {nationalId: infer U} ? U : never;
var nId3: GetNati
浏览 0提问于2018-12-14得票数 1
回答已采纳
3回答
我在Microsoft docs网站上读到了关于typedef和using的文章：。
#include <stdlib.h>
#include <new>
template <typename T> struct MyAlloc {
typedef T value_type; // Failed to understand why it is needed
MyAlloc() { }
template <typename U> MyAlloc(const MyAlloc<U>&) { } // Fa
浏览 0提问于2021-06-07得票数 2
回答已采纳
为什么Stream::reduce方法中的累加器参数是BiFunction而不是像组合器参数那样的BinaryOperator。
为什么它的类型是BiFunction<U, ? super T, U>？为什么是T？应该是BiFunction<U, ? extends U, U>吗
浏览 2提问于2016-12-08得票数 6
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
