type_typedef - CSDN
精华内容
参与话题
  • type()

    2019-06-12 11:06:03
    type()函数既可以返回一个对象的类型,又可以创建出新的类型 通过type()函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()函数创建出class ...

    type()函数既可以返回一个对象的类型,又可以创建出新的类型
    通过type()函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()函数创建出class
    正常情况下,我们都用class Xxx…来定义类,但type()函数也允许动态创建出类来

    查看数据类型
      type()函数可以查看一个类型或变量的类型

    	  class Hello(object):  #定义一个hello.py文件,并定义一个Hello class
              def hello(self, name='world'):
                  print('Hello, %s.' % name)
            
            
          from hello import Hello
          h = Hello()
          h.hello()    #输出:Hello, world.
          print(type(Hello))    #输出:<class 'type'>,Hello是一个class,它的类型就是type
          print(type(h))    #输出:<class 'hello.Hello'>,h是一个实例,它的类型就是class Hello
    

    动态创建类
      type()函数既可以返回一个对象的类型,又可以创建出新的类型
      比如,可以通过type()函数创建出类,而无需通过class 类名(object)…的定义

    通过type()函数创建类,需依次传入3个参数:
        1) class的名称;
        2) 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
        3) class的方法名称与函数绑定

    def fn(self, name='world'): # 先定义函数
                print('Hello, %s.' % name)
                
            Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class,创建Hello类,父类是object,类方法绑定的是fn
            h = Hello()
            h.hello()    #输出:Hello, world
            print(type(Hello))    #输出:<class 'type'>
            print(type(h))    #输出:<class '__main__.Hello'>
    
    展开全文
  • Type类型详解

    千次阅读 2018-01-09 21:44:55
    什么是Type? 引用网上的话来说就是: Type是一个空接口,所有类型的公共接口(父接口),其意义表示Java所有类型,这里所谓的类型是从Java整个语言角度来看的,比如原始类型、参数化类型(泛型)、类型变量及其数组...

    什么是Type?

    引用网上的话来说就是:
    Type是一个空接口,所有类型的公共接口(父接口),其意义表示Java所有类型,这里所谓的类型是从Java整个语言角度来看的,比如原始类型、参数化类型(泛型)、类型变量及其数组等,可以理解为,Class(类)是Java对现实对象的抽象,而Type是对Java语言对象的抽象。

    Type的类型

    实现了Type接口的子接口为GenericArrayType(泛型数组类型),ParmeterizedType(参数化类型),TypeVariable<D>(类型变量),WildcardType(通配符类型)。实现了Type接口的子类有Class(类)。所有Type一共可以表示这5类数据。主要介绍的就是四个子接口。

    Type的用处

     由于java1.5引入了泛型这一概念,大大方便了我们代码的编写和优化,但是考虑到泛型擦除这一问题,当我们的代码在运行时期会擦除所有的泛型,这一我们在运行时期想要获取某一类原来是带有泛型的,而后来被擦除了的数据的泛型类型时就会有问题。所以java引入了Type这一概念。Type也主要是为在运行时期获取泛型而服务。

    接下来,我们开始介绍泛型中各子接口和子类的作用,在开始介绍之前我们了解一下编码过程中主要的运用到泛型的情况。
    1.List<T>
    2.Set<T> 
    3.Map<K,V>
    4.class<?>(自定义类或接口的泛型)

    ParmeterizedType(参数化类型)的作用

        parameterizedType主要是用来表示 如 Collection<String>或者Class<T>。parameterizedType表示的类型非常的简单,只要带着泛型,除了不可以是数组和本类上定义的泛型以外,其他都被列入ParameterizedType的范围。

    ParameterizedType的主要方法:

    Type[] getActualTypeArguments()
             返回表示此类型实际类型参数的 Type 对象的数组。
    
     Type getOwnerType()
    
             返回 Type 对象,表示此类型是其成员之一的类型。
    
     Type getRawType()
    
              返回 Type 对象,表示声明此类型的类或接口。
    接下来我们来看一个例子。
    示例一:
    现在有三个类,分别为Person,TypeBean以及ParameterizedTypeTest
    Person类
    public class Person {
    	@Override
    	public String toString() {
    		return "Person []";
    	}
    	 class Animal <T> {
    		public String name;
    	}
    }

    TypeBean类
    public class TypeBean<T> {
    	public  List<String> list;
    	private  Set<String>[] set;
    	private  List noGerList;
    	Map.Entry<String,Integer> entry;
    	Person.Animal<String> animal;
    	String str = new String();
    	T t;
    }


    ParameterizedTypeTest类
    public class ParameterizedTypeTest{
    	public static void main(String[] args) throws Exception {
    		Class<TypeBean> bean = (Class<TypeBean>) Class.forName("TypeBean");
    		Field[] declaredFields = bean.getDeclaredFields();
    		int i =1;
    		for (Field field : declaredFields) {
    			field.setAccessible(true);
    			System.out.println("--------------"+i);
    			System.out.println("field name is : "+field.getName());
    			 System.out.print("field.getGenericType() instanceof ParameterizedType");
    			 System.out.println("--------"+(field.getGenericType() instanceof ParameterizedType));
    			 if(field.getName().equals("animal")){
    				 ParameterizedType type = (ParameterizedType) field.getGenericType();
    				 Type ownerType = type.getOwnerType();
    				 System.out.println("Person.Animal<String>的ownerType是。。。"+ownerType);
    				 Type rawType = type.getRawType();
    				 System.out.println("Person.Animal<String>的rawType是"+rawType);
    				 Type[] actualTypeArguments = type.getActualTypeArguments();
    				 for (Type type2 : actualTypeArguments) {
    					System.out.println(type2.getTypeName()+"获取到的actualTypeArguments分别为:"+type2.getTypeName());
    				}
    				 System.out.println("Person.Animal<String> instanceof ParameterizedType -----"+(type instanceof ParameterizedType));
    			 }
    			 System.out.println("--------------"+i);
    			i++;
    			
    		}
    	}
    }


    运行ParameterizedTypeTest类得到的结果如下。
    --------------1
    field name is : list
    field.getGenericType() instanceof ParameterizedType--------true
    --------------1
    --------------2
    field name is : set
    field.getGenericType() instanceof ParameterizedType--------false
    --------------2
    --------------3
    field name is : noGerList
    field.getGenericType() instanceof ParameterizedType--------false
    --------------3
    --------------4
    field name is : entry
    field.getGenericType() instanceof ParameterizedType--------true
    --------------4
    --------------5
    field name is : animal
    field.getGenericType() instanceof ParameterizedType--------true
    Person.Animal<String>的ownerType是。。。class Person
    Person.Animal<String>的rawType是class Person$Animal
    java.lang.String获取到的actualTypeArguments分别为:java.lang.String
    Person.Animal<String> instanceof ParameterizedType -----true
    --------------5
    --------------6
    field name is : str
    field.getGenericType() instanceof ParameterizedType--------false
    --------------6
    --------------7
    field name is : t
    field.getGenericType() instanceof ParameterizedType--------false
    --------------7
    
    第一个字段List<String> list 是ParameterizedType。
    第二个字段Set<String>[] set由于是数组,所以不是ParameterizedType。
    第三个字段List noGerList由于没有带泛型,所以也不是ParameterizedType。
    第四个字段Map.Entry<String,Integer> entry 是parameterizedType。
    第五个字段Person.Animal<String> animal 是parameterizedType。此处我们进一步使用了ParameterizedType的3个方法演示给大家看。我们可以看到ownerType是animal的外部类Person。这也印证了获取到的类型(Person)为原类型(Person.Animal)是其(Person)成员之一。(这里还有其他情况欢迎在评论区告诉。
    而rawType则是其自身类型。
    getActualTypeArguments()获取到的Type数组则是泛型中的所有类型。(例如Map<k,v>则获取到的数组中包含k,v这两个类型。并且k在前,v在后。)
    第六个字段String str = new String();由于没有带泛型所有不是parameterizedType。
    第七个字段T t 由于是本类上定义的泛型,所以也不行。

    TypeVariable<D>(类型变量)的作用

    TypeVariable 是各种类型变量的公共高级接口。类型变量在反射方法首次需要时创建(在此包中指定)。如果类型变量 t 由类型(即类、接口或注释类型)T 引用,而且 T 由 T 的第 n 个封闭类声明(请参见 JLS 8.1.2),那么创建 t 需要解析(请参见 JVMS 5)T 的第 i 个封闭类,其中 i = 0 到 n(包含)。创建某个类型变量决不能导致创建其边界。重复创建类型变量没有效果。

    可以在运行时将多个对象实例化,以表示一个给定的类型变量。尽管类型变量仅创建一次,这并不意味着任何缓存实例的要求都表示类型变量。不过,表示类型变量的所有实例彼此必须相等 (equal())。因此,使用类型变量的用户决不能依靠实现此接口的类实例的身份。


    这是api中的介绍,其实非常简单。这就是我们非常常用的声明类时的泛型。

    例如: 
    public class Test<T>{

    }
    这里的T的类型就属于TypeVariable。(注:T不能为数组。)

    TypeVariable的主要方法

    Type[] getBounds() 
              返回表示此类型变量上边界的 Type 对象的数组。如上边界未显式声明,则为Object。
     D getGenericDeclaration() 
              返回 GenericDeclaration 对象,该对象表示声明此类型变量的一般声明。 
     String getName() 
              返回此类型变量的名称,它出现在源代码中。
    
    示例二:
    现在有3个类 Person,TypeVariableBean,TypeVariableTest
    TypeVariableBean类
    public class TypeVariableBean<T> {
    	public  List<String> list;
    	Class<?> clz;
    	private  Set<String>[] set;
    	private  List noGerList;
    	Map.Entry<String,Integer> entry;
    	Person.Animal<String> animal;
    	String str = new String();
    	T t;
    }
    Person类
    public class Person {	
    	@Override
    	public String toString() {
    		return "Person []";
    	}
    	 class Animal <T> {
    		public String name;
    	}
    }
    TypeVariableTest类
    public class TypeVariableTest {
    	public static void main(String[] args) {
    		Field[] declaredFields = TypeVariableBean.class.getDeclaredFields();
    		for (Field field : declaredFields) {
    			field.setAccessible(true);
    			Type type = field.getGenericType();
    			System.out.println("field.getGenericType() instanceof TypeVariable ? ------ "+(type instanceof TypeVariable));
    			if(field.getGenericType() instanceof TypeVariable){
    				Type[] bounds = ((TypeVariable) type).getBounds();
    				int i = 0;
    				for (Type type2 : bounds) {
    					System.out.println("------------"+i);
    					System.out.println("上边界是:"+type2.getTypeName());
    					System.out.println("------------"+i);
    					i++;
    				}
    				GenericDeclaration genericDeclaration = ((TypeVariable) type).getGenericDeclaration();
    				System.out.println("TypeeVariable's Name::::"+((TypeVariable) type).getName());
    				System.out.println(genericDeclaration);
    			}
    		}
    	}
    }


    此时我们运行TypeVariableTest类时。得到的结果是:
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ true
    ------------0
    上边界是:java.lang.Object
    ------------0
    TypeeVariable's Name::::T
    class TypeVariableBean
    我们可以看出,只有最后一个是我们自己在类上定义的泛型时才是TypeVariable。此时的上边界是Object,因为我们没有显式的定义其上边界,现在我们改变一下TypeVariableBean这个类的泛型上边界。
    更改后的TypeVariableBean类
    public class TypeVariableBean<T extends Person & Serializable> {
    	public  List<String> list;
    	Class<?> clz;
    	private  Set<String>[] set;
    	private  List noGerList;
    	Map.Entry<String,Integer> entry;
    	Person.Animal<String> animal;
    	String str = new String();
    	T t;
    }
    这时我们运行的结果如下
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ false
    field.getGenericType() instanceof TypeVariable ? ------ true
    ------------0
    上边界是:Person
    ------------0
    ------------1
    上边界是:java.io.Serializable
    ------------1
    TypeeVariable's Name::::T
    class TypeVariableBean
    这时就出现了两个上边界。

    GenericArrayType(泛型数组类型)的作用

    顾名思义,只有是带泛型的,并且是数组的那就属于GenericArrayType的范畴。

    GenericArrayType的主要方法:

    Type	getGenericComponentType() 
              返回表示此数组的组件类型的 Type 对象。
    示例三:
    有四个类 Person ,PersonInterface,GenericArrayTypeBean,GenericArrayTypeTest
    Person类
    public class Person {	
    	@Override
    	public String toString() {
    		return "Person []";
    	}
    	 class Animal <T> {
    		public String name;
    	}
    }


    PersonInterface类
    public interface PersonInterface {
    }
    GenericArrayTypeBean类
    public class GenericArrayTypeTest {
    	public static void main(String[] args) {
    		Field[] fields = GenericArrayTypeBean.class.getDeclaredFields();
    		int i =1;
    		for (Field field : fields) {
    			Type type = field.getGenericType();	
    			System.out.println("----------"+i);
    				if(type instanceof ParameterizedType){
    					System.out.println(type.getTypeName());
    					System.out.println("field.getGenericType() instanceof ParameterizedType::");
    				}else if(type instanceof TypeVariable){
    					System.out.println(type.getTypeName());
    					System.out.println("field.getGenericType() instanceof TypeVariable::");
    				}else if(type instanceof GenericArrayType){
    					System.out.println(type.getTypeName());
    					System.out.println("field.getGenericType() instanceof GenericArrayType::");
    					Type genericComponentType = ((GenericArrayType) type).getGenericComponentType();
    					System.out.println(type.getTypeName()+"数组的组成为:"+genericComponentType.getTypeName());
    				}else if(type instanceof Class){
    					System.out.println(type.getTypeName());
    					System.out.println("field.getGenericType() instanceof Class::");
    				}else{
    					System.out.println(type.getTypeName()+" instanceof "+type.getClass());
    				}
    				System.out.println("----------"+i);
    				i++;	
    		}
    	}
    }
    运行GenericArrayTypeTest类的结果为:
    ----------1
    java.util.List<Person>[]
    field.getGenericType() instanceof GenericArrayType::
    java.util.List<Person>[]数组的组成为:java.util.List<Person>
    ----------1
    ----------2
    java.util.Set<K>
    field.getGenericType() instanceof ParameterizedType::
    ----------2
    ----------3
    java.util.Map<K, V>
    field.getGenericType() instanceof ParameterizedType::
    ----------3
    ----------4
    java.util.List<Person>
    field.getGenericType() instanceof ParameterizedType::
    ----------4
    ----------5
    K
    field.getGenericType() instanceof TypeVariable::
    ----------5
    ----------6
    K[]
    field.getGenericType() instanceof GenericArrayType::
    K[]数组的组成为:K
    ----------6
    ----------7
    Person
    field.getGenericType() instanceof Class::
    ----------7
    ----------8
    java.lang.String
    field.getGenericType() instanceof Class::
    ----------8
    ----------9
    PersonInterface
    field.getGenericType() instanceof Class::
    ----------9
    由此我们可以看出只要是带泛型,并且是数组的就属于GenericArrayType。并且getGenericComponentType方法就是获得该数组的组成类型。

    WildcardType(通配符类型)的作用

    表示通配符类型参数。

    WildcardType是依托于ParameterizedType和GenericArrayTypeTest而存在的。

    示例如下:

    Class<?>
    List<? extends Number>
    Set<? super T>

    WildcardType的主要方法

     Type[] getLowerBounds() 
              返回表示此类型变量下边界的 Type 对象的数组。 
     Type[] getUpperBounds() 
              返回表示此类型变量上边界的 Type 对象的数组。 
    


    这个类型比较好理解,直接上例子
    示例四:WildcardTypeBean,WildcardTypeTest
    WildcardTypeBean类
    public class WildcardTypeBean<K extends Number & Serializable,V> {
    	List<? extends Person>[] list;
    	Set<? super Man> set; 
    	K k;
    }
    WildcardTypeTest类
    public class WildcardTypeTest {
    	public static void main(String[] args) throws Exception{
    		Field[] fields = WildcardTypeBean.class.getDeclaredFields();
    		for (int i = 0; i <fields.length; i++) {
    			System.out.println("--------------"+(i+1));
    			Field field = fields[i];
    			System.out.println("file:"+field);
    			Type type = field.getGenericType();
    			if(type instanceof GenericArrayType){
    				GenericArrayType gat = (GenericArrayType)type;
    				ParameterizedType genericComponentType = (ParameterizedType)gat.getGenericComponentType();
    				Type[] actualTypeArguments = genericComponentType.getActualTypeArguments();
    				WildcardType t = (WildcardType)actualTypeArguments[0];
    				Type[] upperBounds = t.getUpperBounds();
    				for (Type type2 : upperBounds) {
    					System.out.println("upperBounds:"+type2.getTypeName());
    				}
    				Type[] lowerBounds = t.getLowerBounds();
    				for (Type type2 : lowerBounds) {
    					System.out.println("lowerBounds:"+type2.getTypeName());
    				}
    			}else if(type instanceof ParameterizedType){
    				WildcardType wildcardType = ((WildcardType)((ParameterizedType) type).getActualTypeArguments()[0]);
    				Type[] lowerBounds = wildcardType.getLowerBounds();
    				for (Type type2 : lowerBounds) {
    					System.out.println("lowerBounds:"+type2.getTypeName());
    				}
    			}else{
    				System.out.println(type.getTypeName()+" instanceof "+type.getClass());
    			}
    			System.out.println("--------------"+(i+1));
    		}
    }


    运行结果:
    --------------1
    file:java.util.List[] WildcardTypeBean.list
    upperBounds:Person
    --------------1
    --------------2
    file:java.util.Set WildcardTypeBean.set
    lowerBounds:Man
    --------------2
    --------------3
    file:java.lang.Number WildcardTypeBean.k
    K instanceof class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
    --------------3
    到此,Type的四个子接口就基本介绍完毕了。如果有错误的地方,欢迎各位大牛在评论区指出!!!








































    展开全文
  • type的用法总结

    2014-08-07 15:05:55
    文章转载于

     文章转载于 :http://www.cnblogs.com/csyisong/archive/2009/01/09/1372363.html


    不管实在C还是C++代码中,typedef这个词都不少见,当然出现频率较高的还是在C代码中。typedef与#define有些相似,但更多的是不同,特别是在一些复杂的用法上,就完全不同了,看了网上一些C/C++的学习者的博客,其中有一篇关于typedef的总结还是很不错,由于总结的很好,我就不加修改的引用过来了,以下是引用的内容(红色部分是我自己写的内容)。

    用途一:

    定义一种类型的别名,而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如:

    char* pa, pb; // 这多数不符合我们的意图,它只声明了一个指向字符变量的指针,

    // 和一个字符变量;

    以下则可行:

    typedef char* PCHAR;

    PCHAR pa, pb;  

    这种用法很有用,特别是char* pa, pb的定义,初学者往往认为是定义了两个字符型指针,其实不是,而用typedef char* PCHAR就不会出现这样的问题,减少了错误的发生。

    用途二:
    用在旧的C代码中,帮助struct。以前的代码中,声明struct新对象时,必须要带上
    struct,即形式为: struct 结构名对象名,如:

    struct tagPOINT1

     {
        int x;

        int y; 
    };

    struct tagPOINT1 p1;

    而在C++中,则可以直接写:结构名对象名,即:tagPOINT1 p1;

    typedef struct tagPOINT
    {
        int x;

        int y;
    }POINT;

    POINT p1; // 这样就比原来的方式少写了一个struct,比较省事,尤其在大量使用的时

    候,或许,在C++中,typedef的这种用途二不是很大,但是理解了它,对掌握以前的旧代

    码还是有帮助的,毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。

    用途三:

    用typedef来定义与平台无关的类型。

    比如定义一个叫 REAL 的浮点类型,在目标平台一上,让它表示最高精度的类型为:

    typedef long double REAL;

    在不支持 long double 的平台二上,改为:

    typedef double REAL;

    在连 double 都不支持的平台三上,改为:

    typedef float REAL;

    也就是说,当跨平台时,只要改下 typedef 本身就行,不用对其他源码做任何修改。

    标准库就广泛使用了这个技巧,比如size_t。另外,因为typedef是定义了一种类型的新别名,不是简单的字符串替换,所以它比宏来得稳健。
         这个优点在我们写代码的过程中可以减少不少代码量哦!

    用途四:

    为复杂的声明定义一个新的简单的别名。方法是:在原来的声明里逐步用别名替换一部

    分复杂声明,如此循环,把带变量名的部分留到最后替换,得到的就是原声明的最简化

    版。举例: 

     原声明:void (*b[10]) (void (*)());

    变量名为b,先替换右边部分括号里的,pFunParam为别名一:

    typedef void (*pFunParam)();

    再替换左边的变量b,pFunx为别名二:

    typedef void (*pFunx)(pFunParam);

    原声明的最简化版:

    pFunx b[10];
     
    原声明:doube(*)() (*e)[9];

    变量名为e,先替换左边部分,pFuny为别名一:

    typedef double(*pFuny)();

    再替换右边的变量e,pFunParamy为别名二

    typedef pFuny (*pFunParamy)[9];

    原声明的最简化版:

    pFunParamy e;

    理解复杂声明可用的“右左法则”:从变量名看起,先往右,再往左,碰到一个圆括号

    就调转阅读的方向;括号内分析完就跳出括号,还是按先右后左的顺序,如此循环,直

    到整个声明分析完。举例:

    int (*func)(int *p);

    首先找到变量名func,外面有一对圆括号,而且左边是一个*号,这说明func是一个指针

    ;然后跳出这个圆括号,先看右边,又遇到圆括号,这说明(*func)是一个函数,所以

    func是一个指向这类函数的指针,即函数指针,这类函数具有int*类型的形参,返回值

    类型是int。

    int (*func[5])(int *);

    func右边是一个[]运算符,说明func是具有5个元素的数组;func的左边有一个*,说明

    func的元素是指针(注意这里的*不是修饰func,而是修饰func[5]的,原因是[]运算符

    优先级比*高,func先跟[]结合)。跳出这个括号,看右边,又遇到圆括号,说明func数

    组的元素是函数类型的指针,它指向的函数具有int*类型的形参,返回值类型为int。

    这种用法是比较复杂的,出现的频率也不少,往往在看到这样的用法却不能理解,相信以上的解释能有所帮助。

    *****以上为参考部分,以下为本人领悟部分*****

    使用示例:

    1.比较一:

    #include <iostream>

    using namespace std;

    typedef int (*A) (char, char);

    int ss(char a, char b)
    {
        cout<<"功能1"<<endl;

        cout<<a<<endl;

        cout<<b<<endl;

        return 0;
    }
     
    int bb(char a, char b)
    {

        cout<<"功能2"<<endl;

        cout<<b<<endl;

        cout<<a<<endl;

        return 0;

    }

    void main()
    {

        A a;

        a = ss;

        a('a','b');

        a = bb;

        a('a', 'b');
    }

    2.比较二:

    typedef int (A) (char, char);

    void main()
    {

        A *a;

        a = ss;

        a('a','b');

        a = bb;

        a('a','b');
    }
     

    两个程序的结果都一样:

    功能1

    a

    b

    功能2

    b

    a

     

    *****以下是参考部分*****

    参考自:http://blog.hc360.com/portal/personShowArticle.do?articleId=57527

    typedef 与 #define的区别:

    案例一:

    通常讲,typedef要比#define要好,特别是在有指针的场合。请看例子:

    typedef char *pStr1;

    #define pStr2 char *;

    pStr1 s1, s2;

    pStr2 s3, s4;
    在上述的变量定义中,s1、s2、s3都被定义为char *,而s4则定义成了char,不是我们

    所预期的指针变量,根本原因就在于#define只是简单的字符串替换而typedef则是为一

    个类型起新名字。

    案例二:

    下面的代码中编译器会报一个错误,你知道是哪个语句错了吗?

    typedef char * pStr;

    char string[4] = "abc";

    const char *p1 = string;

    const pStr p2 = string;

    p1++;

    p2++;

      是p2++出错了。这个问题再一次提醒我们:typedef和#define不同,它不是简单的

    文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和

    const long x本质上没有区别,都是对变量进行只读限制,只不过此处变量p2的数据类

    型是我们自己定义的而不是系统固有类型而已。因此,const pStr p2的含义是:限定数

    据类型为char *的变量p2为只读,因此p2++错误。虽然作者在这里已经解释得很清楚了,可我在这个地方仍然还是糊涂的,真的希望哪位高手能帮忙指点一下,特别是这一句“只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已”,难道自己定义的类型前面用const修饰后,就不能执行更改运算,而系统定义的类型却可以?


    展开全文
  • HTML中type类型常用种类

    千次阅读 2019-10-27 17:39:36
    button:定义可点击的按钮... <input type="button" name="" id="" value="按钮"><br> <br> checkbox:定义复选框。 <br> <input type="checkbox" name="" id="">男<br> ...

    button:定义可点击的按钮(通常与 JavaScript 一起使用来启动脚本)。

    <input type="button" name="" id="" value="按钮"><br>
    <br>
    

    checkbox:定义复选框

    <br>
    <input type="checkbox" name="" id=""><br>
    <input type="checkbox" name="" id="" checked><br>
    <br>
    

    color:定义拾色器。

    <br>
    <input type="color" name="" id=""><br>
    <br>
    

    date:定义 日期控件(包括年、月、日,不包括时间)。

    <br>
    <input type="date" name="" id=""><br>
    <br>
    

    time:定义用于输入时间的控件(不带时区)

    <br>
    <input type="time" name="" id=""><br>
    <br>
    

    datetime-local:定义日期和时间控件(包括年、月、日、时、分、秒、几分之一秒,不带时区)。

    <br>
    <input type="datetime-local" name="" id=""><br>
    <br>
    

    datetime:定义 日期和时间控件(包括年、月、日、时、分、秒基于 UTC 时区)。

    <br>
    <form action="">生日 (日期和时间):<input type="datetime" name="" id=""> <input type="submit" name="" id="" value="提交"></form><br>
    <br>
    

    month:定义 年 和月控件(不带时区)

    <br>
    <input type="month" name="" id=""><br>
    <br>
    

    week:定义 周 和年 控件(不带时区)。

    <br>
    <input type="week" name="" id=""><br>
    <br>
    

    email:定义用于 邮箱地址的字段

    <br>
    <form action=""></form>E-mail:<input type="email" name="" id=""></form><br>
    <br>
    

    file:定义文件选择字段和 “浏览…” 按钮,供文件上传

    <br>
    <input type="file" name="" id=""><br>
    <br>
    

    hidden:定义隐藏输入字段

    <br>
    <input type="hidden" name="" id=""><br>
    <br>
    

    image:定义图像作为提交按钮

    <br>
    <input type="image" name="" id=""><br>
    <br>
    

    number:定义用于输入数字的字段

    <br>
    <input type="number" name="" id=""><br>
    <br>
    

    password:定义密码字段(字段中的字符会被遮蔽)。

    <br>
    <input type="password" name="" id=""><br>
    <br>
    

    radio:定义单选按钮。

    <br>
    <input type="radio" name="" id=""><br>
    <input type="radio" name="" id="" checked><br>
    <br>
    

    range:定义用于精确值不重要的输入数字的控件(比如 slider 控件)。

    <br>
    <input type="range" name="" id=""><br>
    <br>
    

    submit:定义提交按钮。

    <br>
    <input type="submit" name="" id="" value="提交"><br>
    <br>
    

    reset:定义重置按钮(重置所有的表单值为默认值)。

    <br>
    <input type="reset" name="" id=""><br>
    <br>
    

    search:定义用于输入搜索字符串的文本字段

    <br>
    <input type="search" name="" id=""><br>
    <br>
    

    tel:定义用于输入电话号码的字段。

    <br>
    输入电话:<input type="tel" name="" id=""><br>
    <br>
    

    text:默认。定义一个单行的文本字段(默认宽度为 20 个字符)。

    <br>
    <input type="text" name="" id=""><br>
    <br>
    

    textarea:定义多行的文本字段比如个人简历。

    <br>
    <input type="textarea" name="" id=""><br>
    <br>
    

    url:定义用于输入 URL 的字段

    <br>
    添加你的主页网址:<input type="url" name="" id=""> 
    

    select/option:定义下拉选框。拓展一个常用的下拉框

    <td>部门:</td>
     			<td>
     			<select required="required"><!-- required表示必须选一个 -->			
     				<option value="开发部" style="display:none">技术开发部</option>
     				<option value="财务部">财务部</option>
     				<option value="销售部">销售部</option>
     				<option value="ceo">公司CEO</option>
     				</select>
     			</td>		
    
    展开全文
  • 认识USB Type-C Type-CB Type-A 接口

    万次阅读 2019-01-08 10:59:03
    USB接口目前主要有四个接口...2,USB Type-B,这种接口类型主要用在打印机等设备上,没有type-A接口常见。 3,Micro-B,这种接口我们都见过,就是手机充电器的接口。 4,USB Type-C,是以后USB接口的发展趋势。...
  • Java中TypeReference用法说明

    万次阅读 2019-11-05 14:06:47
    用途 在使用fastJson时,对于泛型的反序列化很多场景下都会使用到TypeReference,例如: void testTypeReference() { List<Integer> list = new ArrayList<>(); list.add(1);... list.ad...
  • Type-C与Type-A、Type-B接口

    万次阅读 2018-05-17 11:38:46
    Type系列的接口除了Type-C,还有Type-A和Type-B。 手机经过的一段时间的迅猛发展,使得我们的生活已经离不开手机了,而手机又离不开充电,现在无线充电还未普及,绝大多数手机都是靠USB充电。USB线,很少有一种技术...
  • 完整的 mime type 列表

    万次阅读 2015-06-26 11:07:29
    转载地址:http://www.sitepoint.com/web-foundations/mime-types-complete-list/ ...Media type and subtype(s) .3dm x-world/x-3dmf .3dmf x-world/x-3dmf
  • mysql中explain的type的解释

    万次阅读 多人点赞 2017-10-11 14:58:08
    连接操作的类型 (1)SYSTEM CONST的特例,当表上只有一条元组匹配 (2)CONST ...WHERE条件筛选后表上至多有一条元组匹配时,比如WHERE ID = 2 (ID是主键,值为2的要么有一条要么没有) ...参与连接运算的表是内表...
  • Type Java类型

    万次阅读 2017-10-13 10:31:05
    Type —— Java类型 Type是一个空接口,所有类型的公共接口(父接口),其意义表示Java所有类型,这里所谓的类型是从Java整个语言角度来看的,比如原始类型、参数化类型(泛型)、类型变量及其数组等。Type的子孙...
  • 文章目录问题:解决方法: 今天测试了一个大牛的去除图片马赛克的代码除了不少的错误,...FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it wil...
  • created和mounted的区别

    2020-03-20 23:03:57
    代码片段: data:(){ return { name:"", age:"", phone:"" } }, created ????){ this.name= “wang” this.age = “11” this.phone =“130999” var x = document.getElementById(“name”)//报错 ...mount...
  • 发生这一错误的主要原因是Controller类中需要接收的是Date类型,但是在页面端传过来的是String类型,最终导致了这个错误。 这里提供两种解决方案,一种是局部转换,一种是全局转换。 一....@Controller ...
  • 细谈Type-C、PD原理(一)

    万次阅读 多人点赞 2020-10-24 09:24:19
    一、Type-C简介以及历史 二、Type-C Port的Data Role、Power Role 三、Type-C的Data/Power Role识别协商/Alt Mode 四、如何进行数据链路的切换 五、相关参数/名词/状态解释 六、PD协议简介 一、Type-C简介...
  • Python进阶(九)-Python陷阱:Nonetype

    万次阅读 多人点赞 2020-09-23 10:55:30
    Python进阶(九)-Python陷阱:Nonetype  今天解决一位网友的问题,内容如下:   请教代码问题def calc_prod(lst): def ff(): print map(lambda x:x*x,lst) return fff = calc_prod([1, 2, 3, 4]) print f()...
  • Android开发之——依赖冲突Program type already present

    万次阅读 多人点赞 2020-07-07 08:48:10
    前言 实际开发中,为了提高开发速度和效率,总避免不了引用第三方提供的依赖和类库,如果含有相同依赖的类库被我们引用时,而他们的版本又不相同,就有可能会导致一系列问题和异常,本文结合本人时间总结和他人经验...
  • java Type 详解

    万次阅读 多人点赞 2019-01-18 19:14:03
    前言错误可分为两种:编译时错误与运行时错误。编译时错误在编译时可以发现并排除,而运行时错误具有很大的不确定性,在程序运行时才能发现,造成的...java 为我们提供了 Type 接口,使用它,我们可以得到这些信息。
  • 最近因为要做一个基于深度学习的人脸识别项目,要用到TensorFlow,但是下载完成后后发现import tensorflow总是出现FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future ...
  • Http请求中Content-Type讲解以及在Spring MVC中的应用

    万次阅读 多人点赞 2015-04-22 16:02:59
    引言: 在Http请求中,我们每天都在使用Content-type来指定不同格式的请求信息,但是却很少有人去全面了解content-type中允许的值有多少,这里将讲解Content-Type的可用值,以及在Spring MVC中如何使用它们来映射...
  • 数据格式汇总及type, astype, dtype区别

    万次阅读 多人点赞 2019-08-23 10:20:02
    标签(空格分隔): python uint8在此输入正文8位的无符号整形数据取值范围从0到255 一singed与unsigned的区别 二float改变类型 643264 to 32 shape翻倍 改变类型 321632 to 16 shape翻倍 改变类型 32float32 to ...
1 2 3 4 5 ... 20
收藏数 6,024,221
精华内容 2,409,688
关键字:

type