`
hqs7636
  • 浏览: 220356 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Traits 特征 2.014

阅读更多
6.14 翻译

(d语言的反射,刚刚翻译了2/3了,浏览器异常退出,气死我。  6.14)

重来了
1.028里没有,谁能翻译一下

请参考:
C++ Traits http://www.cnblogs.com/hush/archive/2004/03/10/2717.html
C++ Type traits http://jjhou.csdn.net/programmer-6-type-traits-ddj.htm

Traits are extensions to the language to enable programs, at compile time, to get at information internal to the compiler. This is also known as compile time reflection. It is done as a special, easily extended syntax (similar to Pragmas) so that new capabilities can be added as required.

特征(Traits)是对程序语言的扩展,在编译期,对编译器内部的信息得到成为可能。 这也被称之为编译期反射。 它被作为特殊的,容易扩展的语法(类似于Pragmas ),这样新的能力能根据需要被添加。

TraitsExpression:
    __traits ( TraitsKeyword , TraitsArguments )

TraitsKeyword:
    isAbstractClass
    isArithmetic
    isAssociativeArray
    isFinalClass
    isFloating
    isIntegral
    isScalar
    isStaticArray
    isUnsigned
    isVirtualFunction
    isAbstractFunction
    isFinalFunction
    hasMember
    getMember
    getVirtualFunctions
    classInstanceSize
    allMembers
    derivedMembers
    isSame
    compiles

TraitsArguments:
    TraitsArgument
    TraitsArgument , TraitsArguments

TraitsArgument:
    AssignExpression
    Type



isArithmetic

If the arguments are all either types that are arithmetic types, or expressions that are typed as arithmetic types, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned.

如果变元是是算术类型,或者表达式是算术类型,那么返回true。 否则,返回false。 如果没有变元,返回false。

import std.stdio;

void main()
{
    int i;
    writefln(__traits(isArithmetic, int));
    writefln(__traits(isArithmetic, i, i+1, int));
    writefln(__traits(isArithmetic));
    writefln(__traits(isArithmetic, int*));
}


Prints:

true
true
false
false


1、isFloating

Works like isArithmetic, except it's for floating point types (including imaginary and complex types).

像isArithmetic一样的工作,浮点类型除外(包括虚数和复数类型)。


2、isIntegral

Works like isArithmetic, except it's for integral types (including character types).

3、isScalar
Works like isArithmetic, except it's for scalar(标量?) types.

4、isUnsigned
Works like isArithmetic, except it's for unsigned无符号 types.

5、isStaticArray
Works like isArithmetic, except it's for static array types.

isAssociativeArray
Works like isArithmetic, except it's for associative关联 array types.


6、isAbstractClass

If the arguments are all either types that are abstract classes, or expressions that are typed as abstract classes, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned.

如果变元是抽象类,或者表达式(的结果)是抽象类,那么返回true。 否则,返回false。 如果没有变元,返回false。

import std.stdio;

abstract class C { int foo(); }

void main()
{
    C c;
    writefln(__traits(isAbstractClass, C));
    writefln(__traits(isAbstractClass, c, C));
    writefln(__traits(isAbstractClass));
    writefln(__traits(isAbstractClass, int*));
}


Prints:

true
true
false
false


7、isFinalClass

Works like isAbstractClass, except it's for final classes.
final classes出外


8、isVirtualFunction

Takes one argument. If that argument is a virtual function, true is returned, otherwise false.

接受一个变元。 如果那变元是一个虚函数,返回true,否则(返回)false。

import std.stdio;

struct S
{
  void bar() { }
}

class C
{
  void bar() { }
}

void main()
{
    writefln(__traits(isVirtualFunction, C.bar));  // true
    writefln(__traits(isVirtualFunction, S.bar));  // false
}



9、isAbstractFunction  (抽象函数)

Takes one argument. If that argument is an abstract function, true is returned, otherwise false.

import std.stdio;

struct S
{
  void bar() { }
}

class C
{
  void bar() { }
}

class AC
{
  abstract void foo();
}

void main()
{
    writefln(__traits(isAbstractFunction, C.bar));   // false
    writefln(__traits(isAbstractFunction, S.bar));   // false
    writefln(__traits(isAbstractFunction, AC.foo));  // true
}



10、isFinalFunction

Takes one argument. If that argument is a final function, true is returned, otherwise false.

import std.stdio;

struct S
{
  void bar() { }
}

class C
{
  void bar() { }
  final void foo();
}

final class FC
{
  void foo();
}

void main()
{
    writefln(__traits(isFinalFunction, C.bar));	  // false
    writefln(__traits(isFinalFunction, S.bar));	  // false
    writefln(__traits(isFinalFunction, C.foo));	  // true
    writefln(__traits(isFinalFunction, FC.foo));  // true
}



11、hasMember

The first argument is a type that has members, or is an expression of a type that has members. The second argument is a string. If the string is a valid property of the type, true is returned, otherwise false.

(接受两个变元)第一个变元是一个有成员的类型,或者表达式(的结果)是有成员的类型(class、struct等)。 第二个变元是一个字符串。 如果字符串是类型的一种有效的属性,返回true,否则(返回)false。

import std.stdio;

struct S
{
    int m;
}

void main()
{   S s;

    writefln(__traits(hasMember, S, "m")); // true
    writefln(__traits(hasMember, s, "m")); // true
    writefln(__traits(hasMember, S, "y")); // false
    writefln(__traits(hasMember, int, "sizeof")); // true
}



12、getMember

Takes two arguments, the second must be a string. The result is an expression formed from the first argument, followed by a '.', followed by the second argument as an identifier.

接受两个变元,第二个必须是一个字符串。 结果是由第一个变元构成的表达式,其后是一‘.’,其后第二个变元是一个标识符。(象 s.mx 这样)


import std.stdio;

struct S
{
    int mx;
    static int my;
}

void main()
{ S s;

  __traits(getMember, s, "mx") = 1;  // same as s.mx=1;
  writefln(__traits(getMember, s, "m" ~ "x")); // 1

  __traits(getMember, S, "mx") = 1;  // error, no this for S.mx
                                     //mx对象实例成员,需要实例化后才能得到
  __traits(getMember, S, "my") = 2;  // ok
                                     //my 是static的,是类成员。 
}



13、getVirtualFunctions

The first argument is a class type or an expression of class type. The second argument is a string that matches the name of one of the functions of that class. The result is an array of the virtual overloads of that function.

第一个变元是一个class类型,或者class类型的表达式, 第二个变元是与类函数名(之一)匹配的字符串。 结果是有效重载函数的一个数组。(大概是把所有有效重载的函数名放在一个数组里)



import std.stdio;

class D
{
    this() { }
    ~this() { }
    void foo() { }
    int foo(int) { return 2; }
}

void main()
{
    D d = new D();

    foreach (t; __traits(getVirtualFunctions, D, "foo"))
	writefln(typeid(typeof(t)));

    alias typeof(__traits(getVirtualFunctions, D, "foo")) b;
    foreach (t; b)
	writefln(typeid(t));

    auto i = __traits(getVirtualFunctions, d, "foo")[1](1);
    writefln(i);
}



Prints:

void()
int()
void()
int()
2


14、classInstanceSize

Takes a single argument, which must evaluate to either a class type or an expression of class type. The result is of type size_t, and the value is the number of bytes in the runtime instance of the class type. It is based on the static type of a class, not the polymorphic type.

接受一个单一的变元,这必须对clss类型或者class类型表达式求值。 结果是类型size_t,而值是class类型的运行时实例中的字节数。 它基于一个类的静态类型,不是多态类型。


15、allMembers

Takes a single argument, which must evaluate to either a type or an expression of type. An array of string literals is returned, each of which is the name of a member of that type combined with all of the members of the base classes (if the class is a type). No name is repeated. Builtin properties are not included.

接受一个单一的变元,这必须对类型或者类型表达式求值。 返回一个(字符)串文字数组,

其中每个名称是由那个类型的(及其?)基类(直接继承的类?待测试)的所有成员构成。?(如果class是一个类型)。

没有名称被重复。 构建属性?不被包括在内。

import std.stdio;

class D
{
    this() { }
    ~this() { }
    void foo() { }
    int foo(int) { return 0; }
}

void main()
{
    auto a = __traits(allMembers, D);
    writefln(a);
    // [_ctor,_dtor,foo,print,toString,toHash,opCmp,opEquals]
}


The order in which the strings appear in the result is not defined.
字符串在结果中出现的顺序没有定义

16、derivedMembers 派生成员

Takes a single argument, which must evaluate to either a type or an expression of type. An array of string literals is returned, each of which is the name of a member of that type. No name is repeated. Base class member names are not included. Builtin properties are not included.

接受一个单一的变元,这必须对类型或类型表达式求值。 返回一个字符串文字的数组,其中每个名称是那类型的一个成员。 名称不被重复。 基类成员名称不被包括。 构建属性不被包括。

import std.stdio;

class D
{
    this() { }
    ~this() { }
    void foo() { }
    int foo(int) { return 0; }
}

void main()
{
    auto a = __traits(derivedMembers, D);
    writefln(a);	// [_ctor,_dtor,foo]
}


The order in which the strings appear in the result is not defined.


17、isSame

Takes two arguments and returns bool true if they are the same symbol, false if not.

接受两个变元,如果他们是相同的符号,就返回true ,否则(返回)false。

import std.stdio;

struct S { }

int foo();
int bar();

void main()
{
    writefln(__traits(isSame, foo, foo)); // true
    writefln(__traits(isSame, foo, bar)); // false
    writefln(__traits(isSame, foo, S));   // false
    writefln(__traits(isSame, S, S));     // true
    writefln(__traits(isSame, std, S));   // false
    writefln(__traits(isSame, std, std)); // true
}


If the two arguments are expressions made up of literals or enums that evaluate to the same value, true is returned.

如果两个变元是有由文字literals或者枚举enums组成的表达式,那么计算到相同的值,就返回true。


18、compiles

Returns a bool true if all of the arguments compile (are semantically correct). The arguments can be symbols, types, or expressions that are syntactically correct. The arguments cannot be statements or declarations.

如果所有变元编译(是语义上正确的),返回true。 变元可以是句法上正确的的符号,类型,或者表达式。 变元不能是语句或者声明。

If there are no arguments, the result is false.

如果没有,结果是false

import std.stdio;

struct S
{
    static int s1;
    int s2;
}

int foo();
int bar();

void main()
{
    writefln(__traits(compiles));                      // false
    writefln(__traits(compiles, foo));                 // true
    writefln(__traits(compiles, foo + 1));             // true
    writefln(__traits(compiles, &foo + 1));            // false
    writefln(__traits(compiles, typeof(1)));           // true
    writefln(__traits(compiles, S.s1));                // true
    writefln(__traits(compiles, S.s3));                // false
    writefln(__traits(compiles, 1,2,3,int,long,std));  // true
    writefln(__traits(compiles, 3[1]));                // false
    writefln(__traits(compiles, 1,2,3,int,long,3[1])); // false
}



This is useful for:
这是有益的:

Giving better error messages inside generic code than the sometimes hard to follow compiler ones.
在代码内部有时能比努力的遵从编译器给出更好的错误信息。?

Doing a finer grained specialization than template partial specialization allows for.
允许比模板部分做的更精细更专业化。  ?





。。。。。。。。。。。。。
加上废掉的部分总共用了6个小时。  14:30完成
分享到:
评论
4 楼 hqs7636 2008-06-15  
哈哈,漂亮,是有点信达雅的意思,谢谢。我翻译的有点像文言文
3 楼 Colorful 2008-06-15  
我理解的意思就是指虚函数,因为经过重载override的函数还是虚函数。

在这里没必要抠字眼。

后面这一段,我们可以这样翻译。

allMembers只接受一个参数,而该参数必须是某类型或类型表达式。
它返回一个字符串数组,而其中每一项都是该类型的成员名称。如果该类型是个类类型的话,还包括基类的成员名称。
数组中所有名称都不重复[译注:这意味着不能确定是否有函数重载],并且不包含内置属性。[译注:这意味着数组中没有诸如stringof,sizeof等名称]
2 楼 hqs7636 2008-06-15  
感谢Colorful兄指教,13、The result is an array of the virtual overloads of that function
其中virtual overloads 怎么理解?虚重载?
感觉你的翻译是对的,符合 getVirtualFunctions 的本意。

还有
15、allMembers

Takes a single argument, which must evaluate to either a type or an expression of type. An array of string literals is returned, each of which is the name of a member of that type combined with all of the members of the base classes (if the class is a type). No name is repeated. Builtin properties are not included.

其中:
each of which is the name of a member of that type combined with all of the members of the base classes

翻成:
其中每个名称是由那个类型的(及其?)基类(直接继承的类?待测试)的所有成员构成。?(如果class是一个类型)。

还有点不踏实。

1 楼 Colorful 2008-06-14  
老实说,翻译的有些惨不忍睹。
翻译的专业词汇值得商榷,也不用逐字翻译。

我翻译了前13个,不敢说一定比楼主翻译的好,大家互相学习吧。

剩下的就交给楼主修正了,敬佩楼主的毅力。

引用
Traits
Traits 是 D 语言扩展,它使程序能在编译时便获得编译器内部信息。这也被称为编译时反射。 我们可以把它作为一项特别的,容易扩展的语法(类似于 Pragmas)以便于按需添加新能力。

TraitsExpression/a>:raitsKeyword , TraitsArguments )

TraitsKeyword:
    isAbstractClass
    isArithmetic
    isAssociativeArray
    isFinalClass
    isFloating
    isIntegral
    isScalar
    isStaticArray
    isUnsigned
    isVirtualFunction
    isAbstractFunction
    isFinalFunction
    hasMember
    getMember
    getVirtualFunctions
    classInstanceSize
    allMembers
    derivedMembers
    isSame
    compiles

TraitsArguments:
    TraitsArgument
    TraitsArgument , TraitsArguments

TraitsArgument:
    AssignExpression
    Type
isArithmetic
isArithmetic

如果参数所有类型都是算术类型,或表达式(结果类型)可以转型为算数类型,返回 true 。否则,返回 false 。如果没有参数,同样返回 false 。

importd main()
{
    int i;
    writefln(__traits(isArithmetic, int));
    writefln(__traits(isArithmetic, i, i+1, int));
    writefln(__traits(isArithmetic));
    writefln(__traits(isArithmetic, int*));
}
Prints:

true
true
false
false
isFloating
类似 isArithmetic, 只不过判断其是否为浮点类型 (包括虚数和复数类型)。

isIntegral
类似 isArithmetic, 只不过判断其是否为整型 (包括字符类型)。

isScalar
类似 isArithmetich, 只不过判断其是否为标量。

isUnsigned
类似 isArithmetic

isStaticArray
类似 isArithmetic, 只不过判断其是否为静态数组类型。.

isAssociativeArray
类似 isArithmetic, 只不过判断其是否为关联数组类型。

isAbstractClass
如果参数所有类型都是抽象类,或者表达式(结果类型) 可以转型为抽象类,返回 true 。否则,返回 false. 如果没有参数,同样返回 false 。

import { int foo(); }

void main()
{
    C c;
    writefln(__traits(isAbstractClass, C));
    writefln(__traits(isAbstractClass, c, C));
    writefln(__traits(isAbstractClass));
    writefln(__traits(isAbstractClass, int*));
}
Prints:true
true
false
false
isFinalClass类似 isAbstractClass, 只不过判断其是否为 final 类。isVirtualFunction判断参数是否为虚函数。如果是,返回 true。否则,返回 false. [译注:这里可以输入多个参数。下同。]import) { }
}

class C
{
  void bar() { }
}

void main()
{
    writefln(__traits(isVirtualFunction, C.bar));  // true
    writefln(__traits(isVirtualFunction, S.bar));  // false
}
isAbstractFunction判断参数是否为抽象函数。如果是,返回 true 。否则,返回 false. import) { }
}

class C
{
  void bar() { }
}

class AC
{
  abstract void foo();
}

void main()
{
    writefln(__traits(isAbstractFunction, C.bar));   // false
    writefln(__traits(isAbstractFunction, S.bar));   // false
    writefln(__traits(isAbstractFunction, AC.foo));  // true
}
isFinalFunction判断参数是否为 final 函数。如果是,返回 true 。否则,返回 false.  import) { }
}

class C
{
  void bar() { }
  final void foo();
}

final class FC
{
  void foo();
}

void main()
{
    writefln(__traits(isFinalFunction, C.bar));   // false
    writefln(__traits(isFinalFunction, S.bar));   // false
    writefln(__traits(isFinalFunction, C.foo));   // true
    writefln(__traits(isFinalFunction, FC.foo));  // true
}
hasMember第一个参数指拥有成员的类型或类型表达式。第二个参数是一个字符串。如果该字符串是一个合法的类型属性,返回 true 。否则返回 false. importass="d_keyword">void main()
{   S s;

    writefln(__traits(hasMember, S, "m")); // true
    writefln(__traits(hasMember, s, "m")); // true
    writefln(__traits(hasMember, S, "y")); // false
    writefln(__traits(hasMember, int, "sizeof")); // true
}
getMember同上。结果为两个参数的格式化表达式。形如第一个参数.第二个参数 = 结果; import> my;
}

void main()
{ S s;

  __traits(getMember, s, "mx") = 1;  // same as s.mx=1;
  writefln(__traits(getMember, s, "m" ~ "x")); // 1

  __traits(getMember, S, "mx") = 1;  // error, no this for S.mx
  __traits(getMember, S, "my") = 2;  // ok
}
getVirtualFunctions第一个参数为类类型或类类型表达式。第二个参数是匹配类中函数名之一的一个字符串。结果则为一个虚函数数组。importn> foo(int) { return 2; }
}

void main()
{
    D d = new D();

    foreach (t; __traits(getVirtualFunctions, D, "foo"))
writefln(typeid(typeof(t)));

    alias typeof(__traits(getVirtualFunctions, D, "foo")) b;
    foreach (t; b)
writefln(typeid(t));

    auto i = __traits(getVirtualFunctions, d, "foo")[1](1);
    writefln(i);
}
Prints:void()
int()
void()
int()
2

相关推荐

    Python库 | os-traits-0.5.0.tar.gz

    资源分类:Python库 所属语言:Python 资源全名:os-traits-0.5.0.tar.gz 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059

    PyPI 官网下载 | os-traits-0.13.0.tar.gz

    2. **特性定义**:通过定义特定的“traits”,可以描述操作系统的特定功能或配置,例如是否存在某个命令行工具或者文件系统支持特定的特性。 3. **类型检查**:在运行时,os-traits库可以验证对象是否符合预设的系统...

    Python库 | link_traits-1.0.3.tar.gz

    资源分类:Python库 所属语言:Python 资源全名:link_traits-1.0.3.tar.gz 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059

    traits-4.6.0-cp36-cp36m-win_amd64.whl

    Python科学计算三维可视化应用中需要安装TVTK库,traits-4.6.0-cp36-cp36m-win_amd64.whl为安装TVTK库所需要的5个库之一,该库为64位的

    C++标准库(第二版)英文版.pdf

    5.4 Type Traitsand Type Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 5.4.1 Purposeof Type Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 5.4.2 Type Traitsin ...

    Google C++ International Standard.pdf

    2 Normative references 2 3 Terms and definitions 3 4 General principles 7 4.1 Implementation compliance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 4.2 Structure of this ...

    c++_traits.pdf

    **2. 多重部分特化的挑战** 部分特化虽然强大,但随着特化数量的增加,代码量也会迅速增长,这会使得维护变得更加困难。因此,我们需要一种机制来简化多重部分特化的编写。 - **示例:使用Traits简化多重部分特化*...

    泛型指標(Iterators)與Traits 技術.zip

    2. 如何使用迭代器遍历容器,包括递增、递减、比较和访问元素。 3. 迭代器的失效情况,如插入、删除元素后迭代器的合法性。 4. Traits技术的原理和应用,如何自定义traits类。 5. 使用标准库中的`std::iterator_...

    R Material_traits.html

    R Material_traits.html

    traits与迭代器.doc

    traits 与迭代器 traits 技术是 C++ 编程语言中的一种泛型编程技术,允许开发者定义一个通用函数或类模板,可以对不同的数据类型进行操作。traits 技术的主要优点是可以提高代码的可重用性和灵活性。 在给定的...

    3.4. Traits:创建交互对话.ipynb

    3.4. Traits:创建交互对话

    callable_traits, callable类型的现代 C 型特征和泛函.zip

    callable_traits, callable类型的现代 C 型特征和泛函 Boost.CallableTraits CallableTraits是一个C 11头库,用于检查。合成和分解可以调用类型。这里有最新的文档,这里是 。在CallableTraits中,被正式地检查过,...

    traits-6.1.0-cp36-cp36m-win_amd64.rar

    包含内容:traits-6.1.0-cp36-cp36m-win_amd64.whl 安装tvtk需要 VTK-7.1.1-cp36-cp36m-win_amd64.whl numpy-1.12.1+mkl-cp36-cp36m-win_amd64.whl traits-4.6.0-cp36-cp36m-win_amd64.whl mayavi-4.5.0+vtk71-cp36...

    PHP 实现代码复用的一个方法 traits新特性_.docx

    2. **调用父类方法**: - 如果 Trait 中的方法需要调用父类中的同名方法,可以使用 `parent` 关键字。这在处理优先级冲突时非常有用,可以避免覆盖父类的行为。 ```php class Base { public function sayHello() ...

    Laraboot: Laravel 5 For Beginners

    Chapter 2: The Development Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 The Fun Part . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 MAC ...

    Learning.Scala.Practical.Functional.Programming.for.the.JVM

    Chapter 2. Working With Data: Literals, Values, Variables, and Types Chapter 3. Expressions and Conditionals Chapter 4. Functions Chapter 5. First Class Functions Chapter 6. Common Collections Chapter...

    go-traits:一个概念包,可帮助使用嵌入式结构和挂钩接口实现混合行为

    特质 go-traits是一个概念包,可使用嵌入式结构和挂钩接口帮助实现行为。 特性列表: traits.Hasher唯一哈希生成器的扩展。... traits.schedule实现traits.schedule以在traits.Init调用的单独goroutine

    downloads.part2.rar

    atomic-boost-1.70.0.tar.gz boostorg-beast-boost-1.70.0.tar.gz boostorg-bimap-boost-1.70.0.tar.gz boostorg-bind-boost-1.70.0.tar.gz boostorg-build-boost-1.70.0.tar.gz boostorg-callable_traits-boost-...

    Rust.Essentials.2nd.Edition.epub

    Chapter 2. Using Variables And Types Chapter 3. Using Functions And Control Structures Chapter 4. Structuring Data And Matching Patterns Chapter 5. Higher Order Functions And Error-Handling Chapter 6....

    英语写作六要素the traits of English writingPPT课件.pptx

    2. **组织结构(Organization)**:良好的组织结构是让读者理解文章的关键。文章应有明确的引言、主体段落和结论,每个部分都应该有其特定的目的。段落之间应有逻辑过渡,确保读者可以流畅地跟随作者的思路。 3. **...

Global site tag (gtag.js) - Google Analytics