请有人解释一下,为什么需要为ForEachLoop实例指定泛型类型?
编译器抱怨的原因:类型不匹配:不能从元素类型对象转换为字符串
JDK 1.5.0_09
import java.util.ArrayList;
import java.util.Collection;
public class ForEachLoop<T> {
public static void main(String[] args) {
// Non functional version
ForEachLoop f = new ForEachLoop();
// Functi
我知道在C++中,泛型实际上并不存在,但是您可以使用template来模拟它。当您构建代码时,编译器会对代码进行预处理,并生成一个新代码,替换为对象声明中指定的实际值的泛型值,然后是真正编译的新代码。例如,假设类A如下所示:
template<class T>
class A
{
T f();
};
然后在代码中的其他地方,我们有A<int> a;。实际编译的代码是:
class A
{
//Replaces T by int in the pre-processing
int f();
};
在这整个介绍之后,让我们讲到重点。
我的问题是:
考虑以下C++程序:
#include <iostream>
using namespace std;
template<typename T>
class example
{
public:
void function (T a)
{
std::cout<<a.size ();
}
};
int main() {
example<string> a; // this doesn't
string b = "a";
//example<int
类subA是A类的子类,我试图重写一个方法,但不知怎么它不允许我重写它。为什么会这样呢?是因为参数中的参数吗?
错误信息:
名称冲突: subA中的add( E#2 )和A中的add(E#2)具有相同的擦除,但它们都不覆盖E#1、E#2是类型变量的其他变量:
E#1扩展了类subA中声明的对象
E#2扩展了A类中声明的对象
SuperClass A:
public class A <E> {
public void add(E toInsert) {...}
}
SubClass subA:
public class subA <E> extends
我试图看看是否可以在Java中模仿模板表达式模式,以便进行优化,比如循环融合。
作为一个例子,我将这个表达式模板示例中的c++类移植到java类:。
首先,模板类VecExpression<E>表示向量表达式。它使用模板参数E,并将E的类类型作为构造函数参数。然后,它将私有变量thisAsE设置为this强制转换为E的类类型。
public abstract class VecExpression <E> {
private VecExpression thisAsE;
public VecExpression(Class<E> type)
这是从编译器内部角度提出的问题。
我对泛型感兴趣,而不是模板(C++),所以我用C#标记了这个问题。而不是Java,因为AFAIK两种语言中的泛型在实现上有所不同。
当我查看语言w/o泛型时,它非常简单,您可以验证类定义,将其添加到层次结构中,仅此而已。
但是如何处理泛型类,更重要的是如何处理对它的引用呢?如何确保每个实例化的静态字段都是单数(即每次解决泛型参数时)。
假设我看到一个电话:
var x = new Foo<Bar>();
我是否向层次结构中添加了新的Foo_Bar类?
更新:到目前为止,我只发现了两篇相关的文章,然而,即使它们在“如何自己做”的意义上也没有太多的细节
给定一个C++类:
template<typename T>
class A {
public:
int a;
T x;
int getA() {return a;}
};
模板专门化是否可以“继承”(没有实际的C++继承)成员,比如A和getA()?此外,在为类编写大量模板专门化的代码时,我是否应该多次键入相同的代码(这有点违背了模板的全部用途),还是对类进行结构调整,使其能够适应专门化(例如,将另一个模板类成员封装在其中,使专门化仅限于该类)?
按照C#规范在10.4 Constants中使用
常量声明中指定的类型必须是s字节、字节、短、ushort、int、uint、long、ulong、char、float、double、十进制、bool、string、枚举类型、或引用类型。每个常量表达式必须产生目标类型的值或可以通过隐式转换转换为目标类型的类型的值(§6.1)。
为什么我不能做下面的事:
public class GenericClass<T>
where T : class
{
public const T val = null;
}
这应该是可能的,因为:
where T : clas
这些表达式都是普通类型的定义:
int num;
bool flag;
但是,一些看起来像普通类型定义的表达式意外地变成了模板的声明(详见下面和)!
下面是相关的代码片段():
#include<iostream>
template<typename T>
class Test
{
public:
static constexpr int sdm = T(nullptr);
static int f(void){static_assert(sizeof(T)==0);}
int g(
也在stackoverflow.com上:
我理解STL概念必须存在,当它们实际上只是文档化的(人工)概念而不能在当时被翻译成C++代码时,称它们为“类”或“接口”是愚蠢的,但是当有机会扩展语言以容纳概念时,它们为什么不简单地修改类和/或引入的接口的功能呢?
一个概念不是非常类似于一个接口(100%没有数据的抽象类)吗?从这个角度来看,在我看来,接口似乎只是缺少对公理的支持,但也许可以将axioms引入C++'s接口(考虑到在C++中假设采用接口来接管概念),不是吗?我认为即使是汽车概念也可以很容易地添加到这样一个C++接口(自动接口LessThanComparable,有人吗?)
c
using System;
namespace ConsoleApplication15
{
using System.Collections.Generic;
using System.Threading;
public static class Program
{
static void Main(string[] args)
{
var test1 = new Test<List<int>>();
var t = new Thread(Tester);
t.Start();
va
我很好奇,并查看了std::vector的实现细节。我不太理解这些代码,但我对“使用”声明感到困惑。我看到很多类也在它们的类中包含这些using语句或typedef。在类中使用using声明有什么意义?它是否引入了一个新的成员变量?我对它的工作方式感到困惑。
using iterator = _Vector_iterator<_Scary_val>;
using const_iterator = _Vector_const_iterator<_Scary_val>;
using reverse_iterator =
以下代码无法按预期编译:
#include<iostream>
class Enclosing {
int x;
class Nested { int y; };
void EnclosingFun(Nested *n) {
std::cout << n->y; // Compiler Error: y is private in Nested
}
};
但是,如果我将EnclosingFun转换为模板成员函数,编译器(gcc-7)不会抱怨访问y:
#include<iostream>
class E
阅读,它说
请注意,模板不能在函数中声明
它不会对书中的任何其他章节或外部资源进行解释和/或交叉引用。
有人能帮我解释一下吗。这可能会在书的后面解释,但还没有。如果我之前解释过了,我一定是错过了。
示例:
int main()
{
class DummyClass // This compiles ok
{
int object;
};
template <typename T> // compile error "expected primary-expression before "template""
cl
注意:这个问题与我的有些关联,但实际上从不同的角度讨论了这个问题。
考虑以下片段:
let toStr a = a.ToString()
let strOp a = string a
let intToStr = 5 |> toStr
let floatToStr = 5.0 |> toStr
let intStrOp = 5 |> strOp
let floatStrOp = 5.0 |> strOp //type inference error
虽然strOp函数使用看起来更优雅的解决方案,并且也能够将单位值转换为字符串,但它似乎并不是真正的泛型,因为它的类型在
假设我有两个类:
class a
{
public void sayGoodbye() { Console.WriteLine("Tschüss"); }
public virtual void sayHi() { Console.WriteLine("Servus"); }
}
class b : a
{
new public void sayGoodbye() { Console.WriteLine("Bye"); }
override public void sayHi() { Console.WriteL
如何传递泛型参数的类名?
class Sample<T>{
public getTypeName(): void {
alert(T.name)
//or
alert(new T().constructor.name)
}
}
class Person {
public FullName:string
}
new Sample<Person>().getTypeName()
我需要把输出打印成"Person“吗?
请考虑以下示例:
template<typename T>
class Base
{
public:
inline void fooBase ()
{
T t; // The following error only occurs when class ABC is not defined at the end of the file: "error: t uses undefined class ABC"
}
protected:
};
class ABC;
class DEF;
class Derived : public Base<
假设我有一个模板类,如:
template <class type, size>
class myTemplate
我有一个抽象的基类:
class myDataType
和各种派生类
class subDataType1 : public myDataType
class subDataType2 : public myDataType
...
class subDataTypeN : public myDataType
我想做的是,打电话:
myTemplate<myDataType, size> myObject;
但是,这显然不起作用,因
class T : public std::string {
public:
T(char* s) : std::string(s){};
};
class X : public T {
public:
X(char* s) : T(s) {};
~X() {};
};
template <typename T> T doIt(const T arg);
int main(int argc, const char* argv[]) {
X s("initial string");