精华内容
下载资源
问答
  • 不同类型的变量可以起相同的名字
    千次阅读
    2021-03-14 17:12:08

    public abstract class A {

    int i=1;

    public void printI() {

    System.out.println("i="+i);

    }

    }

    public class B  extends A{

    int i=2;

    public static void main(String[] args) {

    B b=new B();

    b.printI();

    }

    }

    那么,控制台打出来的i的值是多少?

    呵呵,如果一下功夫就能说出正确结果1,那么,下面部分就不需要往下看了。

    1、类的继承知识点

    (1)java不支持多重继承,也就是说子类至多只能有一个父类

    (2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法

    (3)子类中定义的成员变量和父类中定义的成员变量相同时,则父类中的成员变量不能被继承

    (4)子类中定义的成员方法,并且这个成员方法的名字,返回类型,及参数个数和类型与父类的某个成员方法完全相同,则父类的成员方法不能被继承。

    2、答案是2者如是说

    子类B中的变量i和父类A中的变量i重名, 那么子类B中的变量i将会覆盖掉父类中的同名变量i. 则访问父类中的变量时jvm会把子类cast到父类.所以,打印出的结果应该是“i=2”;

    3、歧义的产生

    歧义的产生最关键的地方是子类B中的变量i将会覆盖掉父类中的同名变量i的覆盖两个字。这里,我觉得这两个字容易误导。应该改为屏蔽或隐藏。因为在这里父类的成员变量是没有被改变。

    4、jvm的执行过程

    (1)子类B 的构造方法被调用,实例化一个B对象,B对象的成员被初始化

    (2)jvm隐含的调用父类的构造方法,实例化一个A对象,A对象的成员被初始化。

    (3)由于A对象的printI()未被屏蔽,所以调用的A对象的printI()函数。

    那么,在这里A的成员函数当然是访问自己的成员变量了。

    5、super关键字

    super关键字在java中的作用是使被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员成员方法。super是用在子类中,目的是访问直接父类中被屏蔽的成员。上面的代码也可以这样写:

    Java代码

    public abstract class A {

    int i=1;

    public void printI() {

    System.out.println("i="+i);

    }

    }

    public class B extends A{

    public int i=2;

    public void printI(){

    super.printI();

    }

    public static void main(String[] args){

    B b= new B();

    b.printI();

    }

    }

    注:

    JVM实例化程序的过程中,若对子类进行实例化,必然要对父类的构造器进行实例化继承。

    C exteds D(){}

    C c = new C();

    构造器,采取先父后子的关系。

    而方法,若调用的方法为子类所覆盖,则主动调用儿子的方法,因为此时,已经继承了父类所拥有的

    相关变量,而方法行为,子类具有相对来说的独立性,可以独立调用。

    D c = new C();

    JVM处理过程,也是如此。

    先继承D的构造器(基因),再加载C独自的构造器,同时,对相关方法进行相应的调用。

    更多相关内容
  • 可变类型,值可以改变: 列表 list 字典 dict 不可变类型,值不可以改变: 数值类型 int, long, bool, float 字符串 str 元组 tuple 看如下代码: 2.修改全局变量 既然全局变量,就是能够在所以的函数中进行...

    1.可变类型与不可变类型

    可变类型,值可以改变:

    • 列表 list
    • 字典 dict

    不可变类型,值不可以改变:

    • 数值类型 int, long, bool, float
    • 字符串 str
    • 元组 tuple

    看如下代码:

    2.修改全局变量

    既然全局变量,就是能够在所以的函数中进行使用,那么可否进行修改呢?

    代码如下:

    3.总结1:

    • 在函数外边定义的变量叫做全局变量
    • 全局变量能够在所有的函数中进行访问
    • 如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错
    • 如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的

    4.可变类型的全局变量

    >>> a = 1
    >>> def f():
    ...     a += 1
    ...     print a
    ...
    >>> f()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 2, in f
    UnboundLocalError: local variable 'a' referenced before assignment
    >>>
    >>>
    >>> li = [1,]
    >>> def f2():
    ...     li.append(1)
    ...     print li
    ...
    >>> f2()
    [1, 1]
    >>> li
    [1, 1]
    

    5.总结2:

    • 在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向,即不能将全局变量指向新的数据。
    • 对于不可变类型的全局变量来说,因其指向的数据不能修改,所以不使用global时无法修改全局变量。
    • 对于可变类型的全局变量来说,因其指向的数据可以修改,所以不使用global时也可修改全局变量。
    展开全文
  • Python 变量类型详解

    千次阅读 2021-02-04 02:26:00
    因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。变量赋值Python 中的变量赋值不需要类型声明。每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。每个变量在使用前都必须赋值,...

    变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

    基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。

    因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。

    变量赋值

    Python 中的变量赋值不需要类型声明。

    每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。

    每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

    等号(=)用来给变量赋值。

    等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

    例如:

    2018101085033977.jpg?20189108519

    以上实例中,100,1000.0和"John"分别赋值给counter,miles,name变量。

    执行以上程序会输出如下结果:

    1001000.0John

    多个变量赋值

    Python允许你同时为多个变量赋值。

    例如:

    a = b = c = 1

    以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。

    您也可以为多个对象指定多个变量。

    例如:

    a, b, c = 1, 2, "john"

    以上实例,两个整型对象1和2的分配给变量 a 和 b,字符串对象 "john" 分配给变量 c。

    标准数据类型

    在内存中存储的数据可以有多种类型。

    例如,一个人的年龄可以用数字来存储,他的名字可以用字符来存储。

    Python 定义了一些标准类型,用于存储各种类型的数据。

    Python有五个标准的数据类型:

    Numbers(数字)

    String(字符串)

    List(列表)

    Tuple(元组)

    Dictionary(字典)

    Python数字

    数字数据类型用于存储数值。

    他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。

    当你指定一个值时,Number对象就会被创建:

    var1 = 1

    var2 = 10

    您也可以使用del语句删除一些对象的引用。

    del语句的语法是:

    del var1[,var2[,var3[....,varN]]]]

    您可以通过使用del语句删除单个或多个对象的引用。例如:

    del var

    del var_a, var_b

    Python支持四种不同的数字类型:

    int(有符号整型)

    long(长整型[也可以代表八进制和十六进制])

    float(浮点型)

    complex(复数)

    一些数值类型的实例:

    2018101085138895.jpg?201891085153

    长整型也可以使用小写"L",但是还是建议您使用大写"L",避免与数字"1"混淆。Python使用"L"来显示长整型。

    Python还支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型

    Python字符串

    字符串或串(String)是由数字、字母、下划线组成的一串字符。

    一般记为 :

    s="a1a2···an"(n>=0)

    它是编程语言中表示文本的数据类型。

    python的字串列表有2种取值顺序:

    从左到右索引默认0开始的,最大范围是字符串长度少1

    从右到左索引默认-1开始的,最大范围是字符串开头

    如果你要实现从字符串中获取一段子字符串的话,可以使用变量 [头下标:尾下标],就可以截取相应的字符串,其中下标是从 0 开始算起,可以是正数或负数,下标可以为空表示取到头或尾。

    比如:

    s = 'ilovepython'

    s[1:5]的结果是love。

    当使用以冒号分隔的字符串,python返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界。

    上面的结果包含了s[1]的值l,而取到的最大范围不包括上边界,就是s[5]的值p。

    加号(+)是字符串连接运算符,星号(*)是重复操作。

    如下实例:

    2018101085216930.jpg?201891085227

    以上实例输出结果:

    2018101085248988.jpg?201891085259

    Python列表

    List(列表) 是 Python 中使用最频繁的数据类型。

    列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(所谓嵌套)。

    列表用[ ]标识。是python最通用的复合数据类型。看这段代码就明白。

    列表中的值得分割也可以用到变量[头下标:尾下标],就可以截取相应的列表,从左到右索引默认0开始的,从右到左索引默认-1开始,下标可以为空表示取到头或尾。

    加号(+)是列表连接运算符,星号(*)是重复操作。

    如下实例:

    2018101085318985.jpg?201891085329

    以上实例输出结果:

    2018101085351519.jpg?20189108542

    Python元组

    元组是另一个数据类型,类似于List(列表)。

    元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。

    2018101085423139.jpg?201891085433

    以上实例输出结果:

    2018101085540447.jpg?201891085550

    以下是元组无效的,因为元组是不允许更新的。而列表是允许更新的:

    2018101085617760.jpg?201891085628

    Python 字典

    字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。

    两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

    字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

    2018101085646385.jpg?201891085658

    输出结果为:

    2018101085718364.jpg?201891085729

    Python数据类型转换

    有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。

    以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。

    2018101085756026.png?20189108586

    总结

    以上所述是小编给大家介绍的Python 变量类型详解,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

    本文标题: Python 变量类型详解

    本文地址: http://www.cppcns.com/jiaoben/python/241199.html

    展开全文
  • 结构体变量和结构体类型的定义

    万次阅读 多人点赞 2019-08-02 16:43:19
    结构体类型定义 定义方式1: Typedef struct LNode { int data; // 数据域 struct LNode *next; // 指针域 } *LinkList; 定义方式2: struct LNode { int data; // 数据域 struct LNode *next; // 指针域 }; ...

     

    结构体类型定义
    定义方式1:
    
    Typedef struct  LNode {
       int  data;  // 数据域
       struct LNode   *next;  // 指针域
    } *LinkList;
    定义方式2:
    
    struct  LNode {
       int  data;  // 数据域
       struct LNode   *next;  // 指针域
    
    };
    Typedef struct  LNode  *LinkList;
    以上两个定义方式是等价的,是将 *LinkList 定 义为 struct LNode 类型,即 LinkList 被定义为一个类型名。这样就可以用 LinkList 来定义说明新的变量了,如:
    
    LinkList  L;
    即将 L 定义为 struct LNode 类型的指针变量。
    
    2.结构体类型变量定义
    定义方式1:
    
    struct  LNode {
       int  data;  // 数据域
       struct LNode   *next;  // 指针域
    
    }LnodeA;
    定义方式2:
    
    struct  LNode {
       int  data;  // 数据域
       struct LNode   *next;  // 指针域
    
    };
    struct  LNode LnodeA;
    以上两个定义方式也是等价的,这样就将 LnodeA 定义为一个 struct LNode 类型的变量,即 LnodeA 为一个 struct LNode 类型的变量名。
    
    结构体内标的定义方式
    1.结构体,透明表区,DATA ELEMENT,DOMAIN
    透明表是对一个物理表的逻辑描述,透明表里有许多字段,并且定义某些字段为 PRIMARY KEY,字段里又包含 DATA ELEMENT,用来描述语言属性和技术属性。DATA ELEMENT 中又包含 DOMAIN,它是定义数据类型和字段长度。
    
    结构体一般是用来定义一个结构变量,有临时数据的储存,没有 PRIMARY KEY,结构体里包含 COMPONENT 而不是 FIELD
    
    2.Internal table 中的属性分为三种 LINE TYPE ,KEY,TABLE KIND。
    LINE TYPE 在 INTERNAL TABLE 里单独的一行叫 LINE TYPE,每一行的结构都一样。
    
    KEY:相当于数据库里的主键。在排序的时候有用,UNIQUE 或 NON-UNIQUE。
    
    TABLE KIND:分为 STANDARD,SORTED,HASHED。
    
    三种类型的内表的定义
    标准表:
    
    DATA itab1 TYPE STANDARD TABLE OF scarr WITH NON-UNIQUE KEY carrid.
    排序表:
    
    DATA itab2 TYPE SORTED TABLE OF scarr WITH NON-UNIQUE KEY carrid.
    哈希表:
    
    DATA itab3 TYPE HASHED TABLE OF scarr WITH UNIQUE KEY carrid.
    一般定义方法(标准表)
    根据数据库表定义标准表
    
    DATA itab4 TYPE TABLE OF scarr.
    根据自建的结构变量定义标准表(最常用)
    
    DATA: BEGIN OF wa,
        carrid TYPE scarr-carrid,
        carrnamen TYPE scarr-carrname,
        END OF wa.
    DATA itab5 LIKE TABLE OF wa.
    根据数据字典中的表类型定义标准表
    
    DATA itab6 TYPE ztabtype00_1.
    根据内表定义内表
    
    DATA itab7 LIKE itab6.
    根据内表定义结构
    
    DATA wa1 LIKE LINE OF itab7.
    3. 定义结构的方式
    
    根据数据字典中的表或者结构来定义程序的结构变量(或类型)
    
    types str1 type spfli.
    data str2 type  sflight.
    自定义程序中的结构变量(或类型)-最常见的
    
    data: begin of wa,
    carrid type spfli-carrid,
    com(10) type c,
    end of wa.
    根据内表定义结构
    
    data wa like line of itab.
    注:根据数据库表定义的一定是结构
    
    同名字段的赋值(重要)
    
    Move-corresponding A  to  B.
    read 是读取内表的一条数据
    
    read table itab like table of wa.
    读一内表的多条数据应用 loop
    
    loop at itab into wa.
    C/C++ 语言中的解释
    结构体定义
    
    结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构。
    
    结构体作用
    
    结构体和其他类型基础数据类型一样,例如 int 类型,char 类型 只不过结构体可以做成你想要的数据类型。以方便日后的使用。 
    
    在实际项目中,结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。  
    
    结构体在函数中的作用不是简便,其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么,只要根据定义使用就可以了。
    
    结构体的大小与内存对齐
    
    结构体的大小不是结构体元素单纯相加就行的,因为我们现在主流的计算机使用的都是 32Bit 字长的 CPU,对这类型的 CPU 取 4 个字节的数要比取一个字节要高效,也更方便。所以在结构体中每个成员的首地址都是4的整数倍的话,取数据元素是就会相对更高效,这就是内存对齐的由来。
    
    每个特定平台上的编译器都有自己的默认"对齐系数"(也叫对齐模数)。程序员可以通过预编译命令 #pragma pack(n),n=1,2,4,8,16 来改变这一系数,其中的n就是你要指定的"对齐系数"。  
    
    规则:
    
      
    1、数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在 offset 为 0 的地方,以后每个数据成员的对齐按照 #pragma pack指定的数值和这个数据成员自身长度中,比较小的那个进行。  
    2、结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐,对齐将按照< span class="marked">#pragma pack 指定的数值和结构(或联合)最大数据成员长度中,比较小的那个进行。  
    3、结合1、2颗推断:当#pragma pack的n值等于或超过所有数据成员长度的时候,这个n值的大小将不产生任何效果。
    C++ 中的结构体
    在 C 语言中,可以定义结构体类型,将多个相关的变量包装成为一个整体使用。在结构体中的变量,可以是相同、部分相同,或完全不同的数据类型。在 C 语言中,结构体不能包含函数。在面向对象的程序设计中,对象具有状态(属性)和行为,状态保存在成员变量中,行为通过成员方法(函数)来实现。C 语言中的结构体只能描述一个对象的状态,不能描述一个对象的行为。在 C++ 中,考虑到 C 语言到 C++ 语言过渡的连续性,对结构体进行了扩展,C++ 的结构体可以包含函数,这样,C++ 的结构体也具有类的功能,与class 不同的是,结构体包含的函数默认为 public,而不是 private。  
    
    C++ 控制台输出例子:
    
     
    实例
    #include <cstdlib> 
    #include <iostream>  //定义结构体  
    using namespace std; 
     
    struct point 
    {  
        //包含两个变量成员 
        int x;  
        int y; 
    };  
     
     
    int main(int argc, char *argv[]) 
    {  
        struct point pt; 
        pt.x=1; 
        pt.y=2; 
        cout<<pt.x<<endl<<pt.y<<endl;
        return EXIT_SUCCESS;
    }
    C++中的结构体与类的区别
    
    类与结构体在 C++ 中只有两点区别,除此这外无任何区别。  
    
    (1)class 中默认的成员访问权限是 private 的,而 struct 中则是 public 的。  
    (2)从 class 继承默认是 private 继承,而从 struct 继承默认是 public 继承。
    这两种定义有什么区别?
    
    typedef struct student
    {
        int num;
        struct student *next;
    }student;
    
    struct student
    {
        int num;
        struct student *next;
    };
    第二个 struct student 是定义了一个 student 结构体,这个明白吧。
    
    第一个是用 typedef 把 struct student 这个结构体类型名字重新定义为 student,也就是说 struct student 和 student 表示同一个事物,都是一个类型的标识符,比如 typedef int zhengshu; 就是你把整型 int 重命名为 zhengshu,下面定义:int i; 和 zhengshu i; 两句就是等价的了。
    
    结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。结构中可以使用不同的数据类型。
    
    结构说明和结构变量定义
    在 Turbo C 中,结构也是一种数据类型,可以使用结构变量,因此,象其它类型的变量一样,在使用结构变量时要先对其定义。
    
    定义结构变量的一般格式为:
    
    struct 结构名
    { 
        类型 变量名;
        类型 变量名;
    ...
    } 结构变量;
    结构名是结构的标识符不是变量名。
    
    类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和无值型)。
    
    构成结构的每一个类型变量称为结构成员,它象数组的元素一样,但数组中元素是以下标来访问的,而结构是按变量名字来访问成员的。
    
    下面举一个例子来说明怎样定义结构变量。
    
    struct string 
    { 
        char name[8]; 
        int age; 
        char sex[4]; 
        char depart[20]; 
        float wage1,wage2,wage3; 
    }person; 
    这个例子定义了一个结构名为 string 的结构变量 person,如果省略变量名 person,则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义时上例变成:
    
    struct string 
    { 
        char name[8]; 
        int age; 
        char sex[4]; 
        char depart[20]; 
        float wage1,wage2,wage3; 
    }; 
    struct string person;
    如果需要定义多个具有相同形式的结构变量时用这种方法比较方便,它先作结构说明,再用结构名来定义变量。
    
    例如:
    
    struct string Tianyr, Liuqi, ...;
    如果省略结构名,则称之为无名结构,这种情况常常出现在函数内部,用这种结构时前面的例子变成:
    
    struct 
    { 
        char name[8]; 
        int age; 
        char sex[4]; 
        char depart[20]; 
        float wage1,wage2,wage3; 
    } Tianyr, Liuqi;
    结构变量的使用
    结构是一个新的数据类型,因此结构变量也可以象其它类型的变量一样赋值、运算,不同的是结构变量以成员作为基本变量。
    
    结构成员的表示方式为:
    
    结构变量.成员名
    如果将结构变量.成员名看成一个整体,则这个整体的数据类型与结构中该成员的数据类型相同,这样就可象前面所讲的变量那样使用。
    
    下面这个例子定义了一个结构变量,其中每个成员都从键盘接收数据,然后对结构中的浮点数求和,并显示运算结果。请注意这个例子中不同结构成员的访问。
    
    实例
    #include <stdio.h>
    #include <conio.h>  
     
    int main() 
    { 
        struct
        { 
            char name[8]; 
            int age; 
            char sex[4]; 
            char depart[20]; 
            float wage1,wage2,wage3; 
        }a; 
        float wage; 
        char c='Y'; 
        while(c=='Y'||c=='y') 
        { 
            printf(\nName:); 
            scanf(%s, a.name); 
            printf(Age:); 
            scanf(%d, &a.wage); 
            printf(Sex:); 
            scanf(%s, a.sex); 
            printf(Dept:); 
            scanf(%s, a.depart); 
            printf(Wage1:); 
            scanf(%f, &a.wage1); 
            printf(Wage2:); 
            scanf(%f, &a.wage2); 
            printf(Wage3:); 
            scanf(%f, &a.wage3); 
            wage=a.wage1+a.wage2+a.wage3; 
            printf(The sum of wage is %6.2f\n, wage);
            printf(Continue?); 
            c=getche(); 
        } 
    }
    结构数组和结构指针
    结构是一种新的数据类型, 同样可以有结构数组和结构指针。
    
    1.结构数组
    
    结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址,可以定义成一个结构数组。如下所示:
    
    struct
    { 
        char name[8]; 
        char sex[4]; 
        int age; 
        char addr[40]; 
    }student[40];
    也可定义为:
    
    struct string
    { 
        char name[8]; 
        char sex[4]; 
        int age; 
        char addr[40]; 
    }; 
    struct string student[40];
    需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为:
    
    结构数组元素.成员名 
    例如:
    
    student[0].name 
    student[30].age 
    实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是一个结构变量, 第二维是结构成员。
    
    注意: 结构数组的成员也可以是数组变量。
    
    例如:
    
    struct a 
    { 
        int m[3][5]; 
        float f; 
        char s[20]; 
    }y[4];
    为了访问结构a中结构变量 y[2] 的这个变量, 可写成 y[2].m[1][4]
    
    2.结构指针
    
    结构指针是指向结构的指针。它由一个加在结构变量名前的* 操作符来定义, 例如用前面已说明的结构定义一个结构指针如下:
    
    struct string
    { 
        char name[8]; 
        char sex[4]; 
        int age; 
        char addr[40]; 
    }*student;
    也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。
    
    struct string *student; 
    使用结构指针对结构成员的访问,与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为:
    
    结构指针名->结构成员 
    其中 -> 是两个符号 - 和 > 的组合,好象一个箭头指向结构成员。例如要给上面定义的结构中 name 和 age 赋值,可以用下面语句:
    
    strcpy(student->name, Lu G.C); 
    student->age=18;
    实际上,student->name 就是 (*student).name 的缩写形式。
    
    需要指出的是结构指针是指向结构的一个指针,即结构中第一个成员的首地址,因此在使用之前应该对结构指针初始化,即分配整个结构长度的字节空间,这可用下面函数完成, 仍以上例来说明如下:
    
    student=(struct string*)malloc(size of (struct string));
    size of (struct string) 自动求取 string 结构的字节长度, malloc() 函数定义了一个大小为结构长度的内存区域,然后将其诈地址作为结构指针返回。
    
    注意:
    
    1. 结构作为一种数据类型,因此定义的结构变量或结构指针变量同样有局部变量和全程变量,视定义的位置而定。
    2. 结构变量名不是指向该结构的地址,这与数组名的含义不同,因此若需要求结构中第一个成员的首地址应该是 &[结构变量名]。
    3. 结构的复杂形式:嵌套结构
    嵌套结构是指在一个结构成员中可以包括其它一个结构,Turbo C 允许这种嵌套。
    
    例如: 下面是一个有嵌套的结构
    
    struct string
    { 
        char name[8]; 
        int age; 
        struct addr address; 
    } student; 
    其中: addr 为另一个结构的结构名, 必须要先进行, 说明, 即
    
    struct addr
    { 
        char city[20]; 
        unsigned lon zipcode; 
        char tel[14]; 
    }
    如果要给 student 结构中成员 address 结构中的 zipcode 赋值, 则可写成:
    
    student.address.zipcode=200001; 
    每个结构成员名从最外层直到最内层逐个被列出,即嵌套式结构成员的表达方式是:
    
    结构变量名.嵌套结构变量名.结构成员名 

     

    结构体定义变量的三种方法
    1.先定义结构体,然后在定义结构体变量
    
    struct stu{ /*定义学生结构体类型*/
        char name[20]; //学生姓名
        char sex; //性别
        long num; //学号
        float score[3]; //三科考试成绩
    }
    struct stu student1,student2; //定义结构体类型变量
    struct stu student3,student4;
    //用此结构体类型,可以定义更多的该结构体类型变量。
    
     
    
    2.定义结构体类型同时定义结构体类型变量
    
    struct data{
        int day;
        int month;
        int year;
    } time1,time2;
    //也可以在定义如下变量:
    struct data time3,time4;
    //用此结构体类型,同样可以定义更多的该结构体类型变量。
    
     
    
    3.直接定义结构体类型变量
    
    
    struct{
        char name[20]; //学生姓名
        char sex; //性别
        long num; //学号
        float score[3]; //三科考试成绩
    } person1,person2; //定义该结构体类型变量
    //该定义方法由于无法记录该结构体类型,所以除直接定义外,不能再定义该结构体类型变量。
    
     
    
    4.在C中定义一个结构体类型要用typedef
    
    
    typedef struct Student{
        int a;
    }Stu;
    //于是在声明变量的时候就可: Stu stu1;
    /*
    如果没有typedef就必须用struct Student stu1;来声明
    这里的Stu, 实际上就是 struct Student的别名
    另外这里也可以不写Student(于是也不能struct Student stu1;了)
    
    typedef struct{
        int a;
    }Stu;
    */
    

     

     

    bq25895StructTypeDef  bq25895A; //再定义变量
    
    
    
    
      typedef struct {
        bool      powerGood;
        bool      chargeFault;
        uint16_t  battryVoltage;
        uint8_t   battryPercentage;
        
        uint16_t  chargeCurrent;
        
      } bq25895StructTypeDef;//定义类型
    
    
    
    lastPowerGood = bq25895A.powerGood;  //直接这样用
    
     //直接这样用
    bq25895ItHandler(&bq25895A);
     //直接这样用
    
    void bq25895ItHandler(bq25895StructTypeDef *p) {
      if (BQ25895_POWER_GOOD == (bq25895ReadReg(BQ25895_RA_PG_STAT) & BQ25895_REG0B_PG_STAT_MASK)) {
        p->powerGood = true;
        if (BQ25895_CHARGE_NORMAL == (bq25895ReadReg(BQ25895_RA_CHRG_FAULT) & BQ25895_REG0C_CHRG_FAULT_MASK)) {
          p->chargeFault = false;
        } else {
          p->chargeFault = true;
        }
      } else {
        p->powerGood   = false;
        p->chargeFault = false;
      }
    }
      typedef enum {
        STATUS_MOVING,    //枚举类型  如果不自定义第一个默认为0
        STATUS_COLORING,  //
        STATUS_COLORED,   //
      } statusTypeDef;
      
      typedef enum {
        TX_MOTION_START_TAB     = 0,
        TX_MOTION_END_TAB       = 12,
        TX_MAGNETIC_START_TAB   = 12,
        TX_MAGNETIC_END_TAB     = 18,
        TX_COLOR_START_TAB      = 18,
        TX_COLOR_END_TAB        = 24,
        TX_BATTERY_TAB          = 24,
        TX_FRAME_LENGTH         = 25,
      } txTabTypeDef;

     

        typedef enum {
        TX_MOTION_START_TAB     = 0,
        TX_MOTION_END_TAB       = 12,
        TX_MAGNETIC_START_TAB   = 12,
        TX_MAGNETIC_END_TAB     = 18,
        TX_COLOR_START_TAB      = 18,
        TX_COLOR_END_TAB        = 24,
        TX_BATTERY_TAB          = 24,
        TX_FRAME_LENGTH         = 25,
      } txTabTypeDef;
    
    //TX_FRAME_LENGTH  25
    typedef struct {
        struct {
          uint8_t _1[TX_FRAME_LENGTH];
          uint8_t _2[TX_FRAME_LENGTH];
        } buffer;
        bool buffer1Latched;
      } txStructTypeDef;
    
    
     extern txStructTypeDef txA;
    
    txRefleshBattery(&txA, bq25895A.battryPercentage);
    
    
    
    void txRefleshBattery(txStructTypeDef *pTx, uint8_t battery) {
      pTx->buffer1Latched = true;
      pTx->buffer._1[TX_BATTERY_TAB] = battery;
      pTx->buffer1Latched = false;
      pTx->buffer._2[TX_BATTERY_TAB] = battery;
    }
    
    
    txClearColorBuffer(&txA);
    
    void txClearColorBuffer(txStructTypeDef *pTx) {
      pTx->buffer1Latched = true;
      for (uint8_t i = TX_COLOR_START_TAB; i < TX_COLOR_END_TAB; ++i) {
        pTx->buffer._1[i] = 0;
      }
      pTx->buffer1Latched = false;
      for (uint8_t i = TX_COLOR_START_TAB; i < TX_COLOR_END_TAB; ++i) {
        pTx->buffer._2[i] = 0;
      }
    }

     

     

    \

      pTx->buffer1Latched = true;
      for (uint8_t i = TX_MAGNETIC_START_TAB, j = 0; i < TX_MAGNETIC_END_TAB; ++i, ++j) {
        pTx->buffer._1[i] = pAk8963->tx[j];
      }
      pTx->buffer1Latched = false;
      for (uint8_t i = TX_MAGNETIC_START_TAB, j = 0; i < TX_MAGNETIC_END_TAB; ++i, ++j) {
        pTx->buffer._2[i] = pAk8963->tx[j];
      }

     

    展开全文
  • 结构体类型与结构体变量

    千次阅读 2020-04-26 11:49:18
    结构体(struct)是由一系列具有相同类型不同类型的数据构成的数据集合,叫做结构体。在C语言中,结构体(struct)指的是一种数据结构,是C语言中聚合数据类型(aggregate data type)的一类。结构体可以被声明为变量、...
  • 问题描述:用循环时常用到调用不同的文件名变量 用字符串作为变量名: eval() 变量名转化为字符串: inputname() 数字变换成字符: num2str() %小例子:使用for循环调用不同变量变量 load('X.mat'); load('Y....
  • IDEA中自动补全变量名及类型

    万次阅读 2019-10-31 21:59:58
    IDEA中自动补全变量名及类型 IDEA中自动补全变量名 如写入了如下代码: mapDataStream.keyBy { freshness => (freshness.channelId + freshness.date) } 下面要为该代码段自动生成变量名: 选中代码段,再...
  • 在需要生成变量名称的地方在表达式后面键入.var,然后敲...变量名称以及变量类型自动生成成功,可以根据需要自己修改变量名称 修改完不要忘记敲回车键,不然一编辑文件,刚才生成的变量名称以及变量类型会丢失。 ...
  • 深入了解C++变量类型有哪些

    千次阅读 2021-06-23 19:32:06
    也就是说只要你在程序中创建了一个变量,不管后面有没有使用到,编译系统就都会自动的在内存中开辟出一个空间用来存放你需要保存的值,而变量就是我们给这个空间所名字。如下我们创建一个变量取名n
  • C++11 变量类型获取typeid

    万次阅读 2021-03-21 02:02:34
    文章目录1、typeid使用1) 原型:const char* name() const;2) 原型:bool before (const type_info& rhs) const;...2 、判断类型是否相等1) 内置类型的比较2) 类的比较3、type_info 类的声明 1、typ
  • c语言基础-变量类型和定义

    千次阅读 2020-09-05 11:42:51
    变量:一个固定的内存地址,其中存储的值可以变化,这个地址的名字在程序体现就是变量 例子: #include “stdio.h” int main(void) { int a = 6; // a 是一个变量 = 赋值号 6 是一个常量 // 将常量6赋值给变量a a =...
  • java变量与数据类型

    千次阅读 2021-03-10 04:39:22
    这是个变量,废话一个变量变量类型变量名,和变量值1)局部变量:在方法内部声明的变量称之为 局部变量2)实例变量:在类中声明但在方法外部的变量称为 实例变量。但他不被声明为静态(未加 static 修辞符)。3)...
  • JAVA基础 引用类型变量和基本类型变量

    千次阅读 多人点赞 2016-08-16 22:32:27
    引用类型变量名字是复杂数据的存储地点。包括类 数组(字符串) 接口 String s="Hello world!"; 许多人都写过这样的语句,但是,我们到底声明了什么呢?一休,你回答一下。 一休:声明了一个String对象,...
  • 父类子类定义相同变量

    千次阅读 2020-05-29 10:54:05
    今天遇到了一个很有意思的问题,父类和子类都定义了一个同名变量,声明一个父类类型a指向子类实例时,a.变量 = 父类的值 代码 public class Father { public int i = 1; public int f = 2; public int getI() { ...
  • 我们在平时写代码中会用到几个函数但是他们的实现功能相同,但是有些细节却不同。例如:交换两个数的值其中包括(int, float,char,double)这些个类型。在C语言中我们是利用不同的函数名来加以区分。 void Swap1(int*...
  • 有了前面两篇的基础,下面正式开扒变量名和内存的关系,先看一段大家很熟悉的代码:  int i; scanf_s("%d", &amp;i);  int i;,在这一句就为i分配了内存(但尚未对这块内存进行初始化),所以可以...
  • 标识符可以简单的理解成一个名字。 在Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则: 1. 标识符可以由字母、...
  • java变量的两种类型

    千次阅读 2019-01-24 16:09:59
    不同类型变量在内存中分配的字节数不同,同时存储方式也是不同的。所以给变量赋值前需要先确定变量类型,即确定了数据需分配内存空间的大小,数据在内存的存储方式。 JAVA是强类型语言。 java中的变量分为两种...
  • 变量的注意事项 注意事项: 变量在某个区域的数据值可以在同一类型范围内不断变化,但不能改变数据类型(强类型转换) 变量在同一作用域(在一个函数或代码块)内不能重名 变量=变量名+值+数据类型,这一点大家需要...
  • Kotlin的变量和数据类型

    千次阅读 2017-12-28 10:23:08
    什么是变量和数据类型 为了方便新手阅读,在这里我们简单介绍下变量和基本数据类型的概念,老司机跳过即可。...变量可以理解为存储数据的容器,用来描述数据,比如在程序中,一个人的名字可以用nam
  • 汇编中的名字(标号和变量

    千次阅读 2020-10-05 21:40:24
    标号和变量 名字分为标号和变量 变量 这里的LIST明显是一个变量 也就是说,在前面的程序中,一定有相应的变量定义语句,比如 LIST DB 3 DUP (0) LIST DB 01H 变量具有三个属性:段基地址、偏移地址和数据类型 而...
  • C++教程-----C++变量类型变量的定义

    千次阅读 2020-03-31 21:36:46
    C++完全可以理解成C的增强版,增加了许多不同的数据类型,并且同时对C向下兼容,同时对C语言数据的结构等等进行了扩展,C++在定义变量的同时不需要再结构名,联合名,枚举名前加上struct,union,enum。 C++中有许多...
  • Python 变量类型 | 菜鸟教程

    千次阅读 2020-12-28 19:14:12
    Python 变量类型变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。因此,变量可以指定不同的数据类型,这些...
  • 之前在项目的存储过程中发现有通过 `DECLARE` 关键字定义...`,这两种类型变量究竟有什么区别却弄不清楚,赶紧上网查询资料,发现还有`@@sql_mode`这样的变量,这一个圈俩圈的到底是什么啊?会不会出现三个圈的情况?
  • UiBot中的变量是动态类型的,无需再定义的时候声明变量类型,即变量的值和类型可以在运行过程中动态改变。这也符合一般脚本语言如Python、Lua、JavaScript的习惯。 定义变量名的方式是: Dim 变量名 再定义变量...
  • Python数据类型变量(Python笔记01)

    千次阅读 2020-12-13 12:51:46
    数据类型变量Python 中的主要数据类型有 int(整数)/float(浮点数)、字符串、布尔值、None、列表、元组、字典、集合等。None每个语言都有一个专门的词来表示空,例如 JavaScript 中的 null, MySQL 中也是用 null ...
  • 变量与数据类型 java基础03

    万次阅读 2020-11-30 08:36:00
    5.1 变量概述 在程序执行的过程中,在某个范围内其值可以发生改变的量,理解:如同数学中的未知数 5.2 变量定义格式 数据类型 变量名 = 初始化值; 注意:格式是固定的,记住格式,以不变应万变 5.3 变量的组成规则 ...
  • Java入门 - 变量与数据类型

    千次阅读 2021-01-13 10:58:36
    变量:是一种能够根据不同环境产生不同值的数据,例如:手机电量。 例如图中的水杯容量,电池容量,人物等级都是变量。 怎么定义变量 在 Java中,我们通过三个元素描述变量变量类型变量名以及变量值。 那什么是...
  • JAVA 入坑教程 | 章节三 变量类型

    千次阅读 2017-02-17 11:11:33
    引用类型变量名字是复杂数据的存储地点。Java语言支持的变量类型有三大类: 局部变量 成员变量 类变量(静态变量)类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。 无论一个...
  • mysql中各种类型变量的定义以及赋值使用

    万次阅读 多人点赞 2016-08-01 17:19:00
    该文总体框架http://www.cnblogs.com/zhuawang/p/4090916.htmlhttp://blog.csdn.net/seteor/article/details/17682551MySQL存储过程中,定义变量有两种方式...可以在一个会话的任何地方声明,作用域是整个会话,称为用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 780,551
精华内容 312,220
关键字:

不同类型的变量可以起相同的名字