精华内容
下载资源
问答
  • 结构体

    2019-02-28 09:36:46
    可用S定义结构体变量 B.可用T定义结构体变量 C.S是struct类型的变量 D.T是struct S类型的变量 答案B [解析] 本题考查typedef,T是struet S的新名称,因此可用T定义结构体变量,但是T并不是变量,只是struct S...
    以下选项中正确的语句组是
    
    A.char s[]; s="BOOK!";
    B.char *s; s={"BOOK!"};
    C.char s[10]; s="BOOK!";
    D.char *s; s="BOOK!";
    答案D
     数组名代表数组的首地址,是一个地址常量,不能对其赋值,所以选项A、C错误;只有在初始化时才可以用花括号,所以选项B错误。
    
    C 结构体C 数组允许定义可存储相同类型数据项的变量,结构是 C 编程中另一种用户自定义的可用的数据类型,它允许您存储不同类型的数据项。结构用于表示一条记录,假设您想要跟踪图书馆中书本的动态,您可能需要跟踪每本书的下列属性:TitleAuthorSubjectBook ID定义结构为了定义结构,您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型,struct 语句的格式如下:struct tag { 
    member-list
    member-list 
    member-list  
    ...
    } variable-list ;
    tag 是结构体标签。member-list 是标准的变量定义,比如 int i; 或者 float f,或者其他有效的变量定义。variable-list 结构变量,定义在结构的末尾,最后一个分号之前,您可以指定一个或多个结构变量。
    下面是声明 Book 结构的方式:struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book;
    在一般情况下,tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例://此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c
    //同时又声明了结构体变量s1
    //这个结构体并没有标明其标签
    struct 
    {
        int a;
        char b;
        double c;
    } s1;
     
    //此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c
    //结构体的标签被命名为SIMPLE,没有声明变量
    struct SIMPLE
    {
        int a;
        char b;
        double c;
    };
    //用SIMPLE标签的结构体,另外声明了变量t1、t2、t3
    struct SIMPLE t1, t2[20], *t3;
     
    //也可以用typedef创建新类型
    typedef struct
    {
        int a;
        char b;
        double c; 
    } Simple2;
    //现在可以用Simple2作为类型声明新的结构体变量
    Simple2 u1, u2[20], *u3;在上面的声明中,第一个和第二声明被编译器当作两个完全不同的类型,即使他们的成员列表是一样的,如果令 t3=&s1,则是非法的。结构体的成员可以包含其他结构体,也可以包含指向自己结构体类型的指针,而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。//此结构体的声明包含了其他的结构体
    struct COMPLEX
    {
        char string[100];
        struct SIMPLE a;
    };
     
    //此结构体的声明包含了指向自己类型的指针
    struct NODE
    {
        char string[100];
        struct NODE *next_node;
    };
    如果两个结构体互相包含,则需要对其中一个结构体进行不完整声明,如下所示:struct B;    //对结构体B进行不完整声明
     
    //结构体A中包含指向结构体B的指针
    struct A
    {
        struct B *partner;
        //other members;
    };
     
    //结构体B中包含指向结构体A的指针,在A声明完后,B也随之进行声明
    struct B
    {
        struct A *partner;
        //other members;
    };
    结构体变量的初始化和其它类型变量一样,对结构体变量可以在定义时指定初始值。实例#include <stdio.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book = {"C 语言", "RUNOOB", "编程语言", 123456};
     
    int main()
    {
        printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
    }
    执行输出结果为:title : C 语言
    author: RUNOOB
    subject: 编程语言
    book_id: 123456访问结构成员为了访问结构的成员,我们使用成员访问运算符(.)。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。
    下面的实例演示了结构的用法:实例#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    int main( )
    {
       struct Books Book1;        /* 声明 Book1,类型为 Books */
       struct Books Book2;        /* 声明 Book2,类型为 Books */
     
       /* Book1 详述 */
       strcpy( Book1.title, "C Programming");
       strcpy( Book1.author, "Nuha Ali"); 
       strcpy( Book1.subject, "C Programming Tutorial");
       Book1.book_id = 6495407;
     
       /* Book2 详述 */
       strcpy( Book2.title, "Telecom Billing");
       strcpy( Book2.author, "Zara Ali");
       strcpy( Book2.subject, "Telecom Billing Tutorial");
       Book2.book_id = 6495700;
     
       /* 输出 Book1 信息 */
       printf( "Book 1 title : %s\n", Book1.title);
       printf( "Book 1 author : %s\n", Book1.author);
       printf( "Book 1 subject : %s\n", Book1.subject);
       printf( "Book 1 book_id : %d\n", Book1.book_id);
     
       /* 输出 Book2 信息 */
       printf( "Book 2 title : %s\n", Book2.title);
       printf( "Book 2 author : %s\n", Book2.author);
       printf( "Book 2 subject : %s\n", Book2.subject);
       printf( "Book 2 book_id : %d\n", Book2.book_id);
     
       return 0;
    }
    当上面的代码被编译和执行时,它会产生下列结果:Book 1 title : C Programming
    Book 1 author : Nuha Ali
    Book 1 subject : C Programming Tutorial
    Book 1 book_id : 6495407
    Book 2 title : Telecom Billing
    Book 2 author : Zara Ali
    Book 2 subject : Telecom Billing Tutorial
    Book 2 book_id : 6495700结构作为函数参数您可以把结构作为函数参数,传参方式与其他类型的变量或指针类似。
    您可以使用上面实例中的方式来访问结构变量:实例#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    /* 函数声明 */
    void printBook( struct Books book );
    int main( )
    {
       struct Books Book1;        /* 声明 Book1,类型为 Books */
       struct Books Book2;        /* 声明 Book2,类型为 Books */
     
       /* Book1 详述 */
       strcpy( Book1.title, "C Programming");
       strcpy( Book1.author, "Nuha Ali"); 
       strcpy( Book1.subject, "C Programming Tutorial");
       Book1.book_id = 6495407;
     
       /* Book2 详述 */
       strcpy( Book2.title, "Telecom Billing");
       strcpy( Book2.author, "Zara Ali");
       strcpy( Book2.subject, "Telecom Billing Tutorial");
       Book2.book_id = 6495700;
     
       /* 输出 Book1 信息 */
       printBook( Book1 );
     
       /* 输出 Book2 信息 */
       printBook( Book2 );
     
       return 0;
    }
    void printBook( struct Books book )
    {
       printf( "Book title : %s\n", book.title);
       printf( "Book author : %s\n", book.author);
       printf( "Book subject : %s\n", book.subject);
       printf( "Book book_id : %d\n", book.book_id);
    }
    当上面的代码被编译和执行时,它会产生下列结果:Book title : C Programming
    Book author : Nuha Ali
    Book subject : C Programming Tutorial
    Book book_id : 6495407
    Book title : Telecom Billing
    Book author : Zara Ali
    Book subject : Telecom Billing Tutorial
    Book book_id : 6495700指向结构的指针您可以定义指向结构的指针,方式与定义指向其他类型变量的指针相似,如下所示:struct Books *struct_pointer;现在,您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址,请把 & 运算符放在结构名称的前面,如下所示:struct_pointer = &Book1;为了使用指向该结构的指针访问结构的成员,您必须使用 -> 运算符,如下所示:struct_pointer->title;让我们使用结构指针来重写上面的实例,这将有助于您理解结构指针的概念:实例#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    /* 函数声明 */
    void printBook( struct Books *book );
    int main( )
    {
       struct Books Book1;        /* 声明 Book1,类型为 Books */
       struct Books Book2;        /* 声明 Book2,类型为 Books */
     
       /* Book1 详述 */
       strcpy( Book1.title, "C Programming");
       strcpy( Book1.author, "Nuha Ali"); 
       strcpy( Book1.subject, "C Programming Tutorial");
       Book1.book_id = 6495407;
     
       /* Book2 详述 */
       strcpy( Book2.title, "Telecom Billing");
       strcpy( Book2.author, "Zara Ali");
       strcpy( Book2.subject, "Telecom Billing Tutorial");
       Book2.book_id = 6495700;
     
       /* 通过传 Book1 的地址来输出 Book1 信息 */
       printBook( &Book1 );
     
       /* 通过传 Book2 的地址来输出 Book2 信息 */
       printBook( &Book2 );
     
       return 0;
    }
    void printBook( struct Books *book )
    {
       printf( "Book title : %s\n", book->title);
       printf( "Book author : %s\n", book->author);
       printf( "Book subject : %s\n", book->subject);
       printf( "Book book_id : %d\n", book->book_id);
    }当上面的代码被编译和执行时,它会产生下列结果:Book title : C Programming
    Book author : Nuha Ali
    Book subject : C Programming Tutorial
    Book book_id : 6495407
    Book title : Telecom Billing
    Book author : Zara Ali
    Book subject : Telecom Billing Tutorial
    Book book_id : 6495700
    位域有些信息在存储时,并不需要占用一个完整的字节,而只需占几个或一个二进制位。例如在存放一个开关量时,只有 0 和 1 两种状态,用 1 位二进位即可。为了节省存储空间,并使处理简便,C 语言又提供了一种数据结构,称为"位域"或"位段"。所谓"位域"是把一个字节中的二进位划分为几个不同的区域,并说明每个区域的位数。每个域有一个域名,允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。典型的实例:用 1 位二进位存放一个开关量时,只有 0 和 1 两种状态。读取外部文件格式——可以读取非标准的文件格式。例如:9 位的整数。位域的定义和位域变量的说明位域定义与结构定义相仿,其形式为:struct 位域结构名 
    {
    
     位域列表
    
    };
    其中位域列表的形式为:类型说明符 位域名: 位域长度 例如:struct bs{
        int a:8;
        int b:2;
        int c:6;
    }data;
    说明 data 为 bs 变量,共占两个字节。其中位域 a 占 8 位,位域 b 占 2 位,位域 c 占 6 位。让我们再来看一个实例:struct packed_struct {
      unsigned int f1:1;
      unsigned int f2:1;
      unsigned int f3:1;
      unsigned int f4:1;
      unsigned int type:4;
      unsigned int my_int:9;
    } pack;
    在这里,packed_struct 包含了 6 个成员:四个 1 位的标识符 f1..f4、一个 4 位的 type 和一个 9 位的 my_int。对于位域的定义尚有以下几点说明:一个位域存储在同一个字节中,如一个字节所剩空间不够存放另一位域时,则会从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如:struct bs{
        unsigned a:4;
        unsigned  :4;    /* 空域 */
        unsigned b:4;    /* 从下一单元开始存放 */
        unsigned c:4
    }
    在这个位域定义中,a 占第一字节的 4 位,后 4 位填 0 表示不使用,b 从第二字节开始,占用 4 位,c 占用 4 位。由于位域不允许跨两个字节,因此位域的长度不能大于一个字节的长度,也就是说不能超过8位二进位。如果最大长度大于计算机的整数字长,一些编译器可能会允许域的内存重叠,另外一些编译器可能会把大于一个域的部分存储在下一个字中。位域可以是无名位域,这时它只用来作填充或调整位置。无名的位域是不能使用的。
    例如:struct k{
        int a:1;
        int  :2;    /* 该 2 位不能使用 */
        int b:3;
        int c:2;
    };
    从以上分析可以看出,位域在本质上就是一种结构类型,不过其成员是按二进位分配的。位域的使用位域的使用和结构成员的使用相同,其一般形式为:位域变量名.位域名
    位域变量名->位域名位域允许用各种格式输出。
    请看下面的实例:实例main(){
        struct bs{
            unsigned a:1;
            unsigned b:3;
            unsigned c:4;
        } bit,*pbit;
        bit.a=1;    /* 给位域赋值(应注意赋值不能超过该位域的允许范围) */
        bit.b=7;    /* 给位域赋值(应注意赋值不能超过该位域的允许范围) */
        bit.c=15;    /* 给位域赋值(应注意赋值不能超过该位域的允许范围) */
        printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */
        pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */
        pbit->a=0;    /* 用指针方式给位域 a 重新赋值,赋为 0 */
        pbit->b&=3;    /* 使用了复合的位运算符 "&=",相当于:pbit->b=pbit->b&3,位域 b 中原有值为 7,与 3 作按位与运算的结果为 3(111&011=011,十进制值为 3) */
        pbit->c|=1;    /* 使用了复合位运算符"|=",相当于:pbit->c=pbit->c|1,其结果为 15 */
        printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */
    }
    上例程序中定义了位域结构 bs,三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的。
    
    
    
    
    
    若有以下语句  typedef struct S  {int g;char h;}T;  以下叙述中正确的是(  )。
    	 A.可用S定义结构体变量
    	B.可用T定义结构体变量
    	C.S是struct类型的变量
    	D.T是struct S类型的变量
    	答案B
    	[解析] 本题考查typedef,T是struet S的新名称,因此可用T定义结构体变量,但是T并不是变量,只是struct S的新名称。
    
    展开全文
  • 第 9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 3 B) 7 C) 6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 结构中一个成员所需的内存容量 ...
  • 第 9 章 结构体 定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s)的输出结果为 A) 3 B) 7 C) 6 D) 4 当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个成员...
  • 第 9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 的输出结果为 A) 3 B) 7 C) 6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个...
  • 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 的输出结果为 A)3 B)7 C)6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个成员所需的内存容量 B...
  • C语言结构体习题及答案 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 第9章 结构体 1定义以下结构体类型 struct s { ...
  • 第9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句printf%d,sizeof(struct s)的输出结果为 A) 3 B) 7 C) 6 D) 4 2 当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个成员...
  • 定义以下结构体数组 struct c { int x; int y; }s[2]={1,3,2,7}; 语句printf("%d",s[0].x*s[1].x)的输出结果为? 思路分析 s[]是struct c类型的数组,struc c有2个int类型的成员,int x和int y,这个题比较...

    题目要求

    定义以下结构体数组

      struct c

         { int x;

           int y;

          }s[2]={1,3,2,7};

    语句printf("%d",s[0].x*s[1].x)的输出结果为?

     思路分析

    s[]是struct c类型的数组,struc c有2个int类型的成员,int x和int y,这个题比较巧妙,s[2]在定义数组的同时进行了初始化,

    初始化的结果:

    s[0].x s[0].y s[1].x s[1].y
    1 3 2 7

    那么,s[0].x  *  s[1].x =1 *2=2

    代码演示 

    #include    <stdio.h>
    int main()    
    {    
    	struct c
    	{
    		int x;
    		int y;
    	}s[2]={1,3,2,7};
    	printf("s[0].x=%d\n",s[0].x);
    	printf("s[1].x=%d\n",s[1].x);	
    	printf("s[0].y=%d\n",s[0].y);
    	printf("s[1].y=%d\n",s[1].y);
    	printf("s[0].x*s[1].x=%d\n",s[0].x*s[1].x);
    }
    
    
    
    

    验证结果

    展开全文
  • 可用T定义结构体变量 T是struct S类型的变量 可用S定义结构体变量 S是struct类型的变量 当定义一个结构体变量时系统分配给它的内存是 结构体中最后一个成员所需内存量 成员中占内存量最大的容量 结构体中第一个成员...
  • C#学习(六)

    2019-09-19 15:39:15
    来源:菜鸟教程 C#结构体Struct) 在 C# 中,结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct关键字用于创建结构体。...为了定义一个结构体,您必须使用 struct 语句。s...

    来源:菜鸟教程

    C# 结构体(Struct)

    在 C# 中,结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体。

    结构体是用来代表一个记录。假设您想跟踪图书馆中书的动态。您可能想跟踪每本书的以下属性:

    • Title
    • Author
    • Subject
    • Book ID

    定义结构体

    为了定义一个结构体,您必须使用 struct 语句。struct 语句为程序定义了一个带有多个成员的新的数据类型。

    例如,您可以按照如下的方式声明 Book 结构:

    struct Books
    {
       public string title;
       public string author;
       public string subject;
       public int book_id;
    };  
    using System;
    using System.Text;
         
    struct Books
    {
       public string title;
       public string author;
       public string subject;
       public int book_id;
    };  
    
    public class testStructure
    {
       public static void Main(string[] args)
       {
    
          Books Book1;        /* 声明 Book1,类型为 Book */
          Books Book2;        /* 声明 Book2,类型为 Book */
    
          /* book 1 详述 */
          Book1.title = "C Programming";
          Book1.author = "Nuha Ali";
          Book1.subject = "C Programming Tutorial";
          Book1.book_id = 6495407;
    
          /* book 2 详述 */
          Book2.title = "Telecom Billing";
          Book2.author = "Zara Ali";
          Book2.subject =  "Telecom Billing Tutorial";
          Book2.book_id = 6495700;
    
          /* 打印 Book1 信息 */
          Console.WriteLine( "Book 1 title : {0}", Book1.title);
          Console.WriteLine("Book 1 author : {0}", Book1.author);
          Console.WriteLine("Book 1 subject : {0}", Book1.subject);
          Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);
    
          /* 打印 Book2 信息 */
          Console.WriteLine("Book 2 title : {0}", Book2.title);
          Console.WriteLine("Book 2 author : {0}", Book2.author);
          Console.WriteLine("Book 2 subject : {0}", Book2.subject);
          Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);      
    
          Console.ReadKey();
    
       }
    }

    C# 结构的特点

    您已经用了一个简单的名为 Books 的结构。在 C# 中的结构与传统的 C 或 C++ 中的结构不同。C# 中的结构有以下特点:

    • 结构可带有方法、字段、索引、属性、运算符方法和事件。
    • 结构可定义构造函数,但不能定义析构函数。但是,您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的,且不能被改变。
    • 与类不同,结构不能继承其他的结构或类。
    • 结构不能作为其他结构或类的基础结构。
    • 结构可实现一个或多个接口。
    • 结构成员不能指定为 abstract、virtual 或 protected。
    • 当您使用 New 操作符创建一个结构对象时,会调用适当的构造函数来创建结构。与类不同,结构可以不使用 New 操作符即可被实例化。
    • 如果不使用 New 操作符,只有在所有的字段都被初始化之后,字段才被赋值,对象才被使用。

    类 vs 结构

    类和结构有以下几个基本的不同点:

    • 类是引用类型,结构是值类型。
    • 结构不支持继承。
    • 结构不能声明默认的构造函数。
    using System;
    using System.Text;
         
    struct Books
    {
       private string title;
       private string author;
       private string subject;
       private int book_id;
       public void getValues(string t, string a, string s, int id)
       {
          title = t;
          author = a;
          subject = s;
          book_id =id;
       }
       public void display()
       {
          Console.WriteLine("Title : {0}", title);
          Console.WriteLine("Author : {0}", author);
          Console.WriteLine("Subject : {0}", subject);
          Console.WriteLine("Book_id :{0}", book_id);
       }
    
    };  
    
    public class testStructure
    {
       public static void Main(string[] args)
       {
    
          Books Book1 = new Books(); /* 声明 Book1,类型为 Book */
          Books Book2 = new Books(); /* 声明 Book2,类型为 Book */
    
          /* book 1 详述 */
          Book1.getValues("C Programming",
          "Nuha Ali", "C Programming Tutorial",6495407);
    
          /* book 2 详述 */
          Book2.getValues("Telecom Billing",
          "Zara Ali", "Telecom Billing Tutorial", 6495700);
    
          /* 打印 Book1 信息 */
          Book1.display();
    
          /* 打印 Book2 信息 */
          Book2.display();
    
          Console.ReadKey();
    
       }
    }

    补充:类与结构体的区别

    1、结构体中声明的字段无法赋予初值,类可以:

    struct test001
    {
        private int aa = 1;
    }

    执行以上代码将出现“结构中不能实例属性或字段初始值设定”的报错,而类中无此限制,代码如下:

    class test002
    {
        private int aa = 1;
    }

    2、结构体的构造函数中,必须为结构体所有字段赋值,类的构造函数无此限制:

    补充:类与结构的选择

    首先明确,类的对象是存储在堆空间中,结构存储在栈中。堆空间大,但访问速度较慢,栈空间小,访问速度相对更快。故而,当我们描述一个轻量级对象的时候,结构可提高效率,成本更低。当然,这也得从需求出发,假如我们在传值的时候希望传递的是对象的引用地址而不是对象的拷贝,就应该使用类了。


    C# 枚举(Enum)

    枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。

    C# 枚举是值类型。换句话说,枚举包含自己的值,且不能继承或传递继承。

    声明 enum 变量

    声明枚举的一般语法:

    enum <enum_name>
    { 
        enumeration list 
    };

    其中,

    • enum_name 指定枚举的类型名称。
    • enumeration list 是一个用逗号分隔的标识符列表。

    枚举列表中的每个符号代表一个整数值,一个比它前面的符号大的整数值。默认情况下,第一个枚举符号的值是 0.例如:

    enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
    
    using System;
    
    public class EnumTest
    {
        enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
    
        static void Main()
        {
            int x = (int)Day.Sun;
            int y = (int)Day.Fri;
            Console.WriteLine("Sun = {0}", x);
            Console.WriteLine("Fri = {0}", y);
        }
    }
    Sun = 0
    Fri = 5

    但是,你也可以自定义每个符号的值:

    using System;
    namespace EnumApplication
    {
        class EnumProgram
        {
            enum Days {
                Mon=71, 
                tue=61, 
                Wed=51, 
                thu=41, 
                Fri=51, 
                Sat=61, 
                Sun=71
            };
    
            static void Main(string[] args)
            {
                int WeekdayStart = (int)Days.Mon;
                int WeekdayEnd = (int)Days.Fri;
                Console.WriteLine("Monday: {0}", WeekdayStart);
                Console.WriteLine("Friday: {0}", WeekdayEnd);
                Console.ReadKey();
            }
        }
    }

    输出结果:

    Monday: 71
    Friday: 51

    枚举列表中的每个符号代表一个整数值,一个比它前面的符号大的整数值。默认情况下,第一个枚举符号的值是 0。第 n 个符号值与第 n-1 个有关。

    class Program
        {
            enum Day { a = 8, b, c = 1,d, e, f, g };
            static void Main(string[] args)
            {
                int a = (int)Day.a; //8
                int b = (int)Day.b;//9
                int c = (int)Day.c;//1
                int d = (int)Day.d;//2
                int e = (int)Day.e;//3
                int f = (int)Day.f;//4
                int g = (int)Day.g;//5
                Console.WriteLine(a);
                Console.WriteLine(b);
                Console.WriteLine(c);
                Console.WriteLine(d);
                Console.WriteLine(e);
                Console.WriteLine(f);
                Console.WriteLine(g);
                Console.ReadKey();
            }
        }

    C# 类(Class)

    当你定义一个类时,你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据,但它定义了类的名称意味着什么,也就是说,类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量成为类的成员。

    类的默认访问标识符是 internal,成员的默认访问标识符是 private

    成员函数和封装

    类的成员函数是一个在类定义中有它的定义或原型的函数,就像其他变量一样。作为类的一个成员,它能在类的任何对象上操作,且能访问该对象的类的所有成员。

    成员变量是对象的属性(从设计角度),且它们保持私有来实现封装。这些变量只能使用公共成员函数来访问。

    C# 中的构造函数

    类的 构造函数 是类的一个特殊的成员函数,当创建类的新对象时执行。

    构造函数的名称与类的名称完全相同,它没有任何返回类型。

    默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数,这种构造函数叫做参数化构造函数。这种技术可以帮助你在创建对象的同时给对象赋初始值

    C# 中的析构函数

    类的 析构函数 是类的一个特殊的成员函数,当类的对象超出范围时执行。

    析构函数的名称是在类的名称前加上一个波浪形(~)作为前缀,它不返回值,也不带任何参数。

    析构函数用于在结束程序(比如关闭文件、释放内存等)之前释放资源。析构函数不能继承或重载。

    using System;
    namespace LineApplication
    {
       class Line
       {
          private double length;   // 线条的长度
          public Line()  // 构造函数
          {
             Console.WriteLine("对象已创建");
          }
          ~Line() //析构函数
          {
             Console.WriteLine("对象已删除");
          }
    
          public void setLength( double len )
          {
             length = len;
          }
          public double getLength()
          {
             return length;
          }
    
          static void Main(string[] args)
          {
             Line line = new Line();
             // 设置线条长度
             line.setLength(6.0);
             Console.WriteLine("线条的长度: {0}", line.getLength());          
          }
       }
    }

    C# 类的静态成员

    我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时,意味着无论有多少个类的对象被创建,只会有一个该静态成员的副本。

    关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量,因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。

    静态变量:所有类的对象所共享

    静态函数:只能访问静态成员,在对象被创建前就已经存在

    如果一个方法被声明为public static,则可以直接通过类名.方法名调用

    但如果没有static修饰,即使在一个类中,也必须通过对象.方法名调用

     

     

     

     

     

     

    展开全文
  • C语言错题集

    2019-12-29 18:24:45
    s结构体类型名,s a定义了a为一个结构体变量 2.表达式10!=9的值是true。 (F\) 其值是 1 3.若函数调用时的实参为变量时,以下关于函数形参和实参的叙述中正确的是( D)。 函数的实参和其对应的形参共占同一存储...

    1.定义结构体typedef struct one { int a;}s; s a;则a为结构体变量()
    答案:正确
    解析:s为结构体类型名,s a定义了a为一个结构体变量

    2.表达式10!=9的值是true。 (F)
    解析:在c语言中正确为1,错误为0;所以其值是 1

    3.若函数调用时的实参为变量时,以下关于函数形参和实参的叙述中正确的是( D)。

    函数的实参和其对应的形参共占同一存储单元
    形参只是形式上的存在,不占用具体存储单元
    同名的实参和形参占同一存储单元
    函数的形参和实参分别占用不同的存储单元

    解析:C语言规定,实参变量对形参变量的数据传递是“值传递”,即单向传递,只由实参传给形参,而不能由形参传回来给实参。在内存中,实参单元与形参单元是不同的单元,所以选D

    4.变量a所占内存字节数是( D )。
    union U
    {char st[4];
    int i;
    long l;
    };
    struct A
    {int c;
    union U u;
    }a;

    A: 4
    B: 5
    C: 6
    D: 8
    解析:共用体所占字节数是里面的成员所占字节数相加,int 4个字节 ,union U u取最长4字节,所以a所占字节数为
    4+4=8.

    5.任何一个算法都必须有的基本结构是( A )

    A: 顺序结构
    B: 条件分支结构
    C: 循环结构
    D: 以上三个都要有
    解析:根据算法的特点
    如果在执行过程中,不需要分类讨论,则不需要有条件结构;
    如果不需要重复执行某些操作,则不需要循环结构;
    但任何一个算法都必须有顺序结构

    6.以下错误的转义字符是(D)

    A: ‘\’
    B: ‘’’
    C: ‘\t’
    D: ‘\80’
    解析:因为“\”后面使用数字表示字符ASCII值默认用的是8进制 用8自然是错的

    7.以下程序输出结果是( B )

    #include <stdio.h>
    main()
    {
    static char a[]=“programe”;
    char *p;
    p=a;
    for(p=a;p<a+8;p+=2)
    putchar(*p);
    }

    A: programme
    B: porm
    C: 有语法错误
    D: Prog
    解析:p[0]=p,p[2]=o,p[4]=r,p[6]=m;
    所以输出为 porm

    8.假定所有变量均已正确说明,下列程序段运行后x的值是( B )。
    a=b=c=0;x=35;
    if(!a) x–;
    else if(b) ; if© x=3;
    else x=4;

    /
    A: 34
    B: 4
    C: 35
    D: 3
    解析:本题考查if else语句。第一个if语句,先判断条件,发现a=0,则!a成立,执行下列的语句,x–,得x=34;第二、三个if语句,判断条件,发现,b=0,c=0,则条件不成立,执行下列的else语句,得x=4。

    9.已知 int x=10, y=20, z=30; 以下语句执行后x, y, z的值是(B )。
    if(x>y)
    z=x;x=y;y=z;

    A: x=10,y=20,z=30 
    B: x=20,y=30,z=30
    C: x=20,y=30,z=10 
    D: x=20,y=30,z=20
    解析:这个题有一个坑,那就是if语句没有假{},所以if只执行接下来的第一个分号之前的内容。
    这里 x!=y,所以只执行x=y和y=z。

    10.已有如下定义和输入语句,若要求a1,a2的值分别为10,20,正确的输入方式是(A)
    int a1,a2;
    scanf("%d%d",&a1,&a2);

    A: 10 20
    B: 1020
    C: 10,20
    D: 10;20
    解析:整型之间输入要隔开,连在一起只会认为是一个整型数据

    11.语句y=*p++;和y=(*p)++;是等价的。(F)
    解析:第一个y = *p;p++.++作用于p上.
    第二个 *p,++作用于p指向的内容上.

    12.定义:char p[20]; 则,p, &p[0] 两者没有区别(T)
    解析:都是指的数组的第一个元素的地址.

    13.枚举类型是一种基本的数据类型 (F)
    解析:在C语言等计算机编程语言中是一种构造数据类型 .

    14.结构化程序设计是以____模块化____设计为中心。

    15.结构化程序设计方法的主要原则可以概括为_ 自顶向下___、逐步求精__、模块化__和____限制使用goto语句

    16.计算圆周率1
    题目描述:
    圆周率可以采用如下公式进行计算:
    在这里插入图片描述
    现要求根据输入的精度e,即最后一项的值不小于精度e时,输出相应的圆周率的值,结果保留六位小数。
    输入
    输入一个精度e。
    输出:
    输出对应的圆周率,结果保留六位小数。

    样例输入;
    0.00005
    样例输出:
    3.141480

    #include<stdio.h>
    int main()
    {
    	double s=0.0,t=1.0,e;
    	int i;
    	scanf("%lf",&e);
    	for(i=1;t>e;i++)
    	{
    		s+=t;
    		t=t*i/(i*2+1);
    	}
    	printf("%.6lf",2.0*s);
    	return 0;
    }
    

    17.Fibonacci数列问题

    题目描述

    有一个有趣的古典数学问题:有一对兔子,从出生后第3个月起每个月都生1对兔子,小兔子长到第3个月后每个月又生1对兔子。假设所有兔子都不死,问每个月兔子的总对数为多少?

    提示:不满1个月的为小兔子,满1个月不满2个月的为中兔子,满3个月以上的为老兔子。每对老兔子每个月会生1对小兔子。因此,每个月的兔子总数依次为1,1,2,3,5,8,13,…。这就是Fibonacci数列。该数列的递归定义如下:f(n)= 1 (n等于1或2);f(n)= f(n-1)+ f(n-2) (n>2)

    请编写递归函数int fib(int n),求出第n个月兔子的总对数。

    输入描述

    输入一个正整数n,表示求第n个月兔子的总对数。

    输出描述

    输出为一行“第n个月兔子的总对数为f”,f值为求出的数列第n项的值f(n)。

    样例输入

    2

    样例输出

    第2个月兔子的总对数为1

    #include<stdio.h>
    long Fibonacci(int m);
    void main()
    {
    	int i;
    	scanf("%d",&i);
       	printf("%d\n",Fibonacci(i));
       	return 0;
    }
    long Fibonacci(int m)
    {
      if(m<=2)
           return 1;
      else 
     	 return Fibonacci(m-1)+Fibonacci(m-2);
    }
    

    18.下面程序段的运行结果是_____A________。
    char s[6]; s=“abcd”; printf(""%s"\n",s);

    A: “abcd”
    B: “abcd "
    C: “abcd”
    D: 编译出错
    解析:给s赋初值为“abcd”,输出s字符串,其中"为转义字符,将” "输出

    19.有如下程序:
    #define N 2
    #define M N+1
    #define NUM 2*M+1
    main()
    {int i;
    for(i=1; i<=NUM; i++) printf("%d\n", i);
    }
    该程序中的for循环执行的次数是( B )。

    A: 5
    B: 6
    C: 7
    D: 8
    解析:NUM=2*2+1+1=6;所以for循环执行六次.

    20.已知大写字母A的ASCII码为65,以下程序的运行结果为( A )。
    #include<stdio.h>
    main( )
    {
    char c1=‘A’,c2=‘Y’;
    printf("%d,%d\n",c1,c2);
    }

    A: 65,89
    B: A,Y
    C: 65,88
    D: 65,90
    解析:A为65,输出65;Y=65+24=89;所以输出89.

    21.合法的数组定义是( D )。
    A: int a[]=“string”;
    B: int a[5]={0,1,2,3,4,5};
    C: char a=“string”;
    D: char a[]={0,1,2,3,4,5};
    解析:A的问题是将字符串的首地址赋值给int类型数组肯定不行类型不一样。
    B的问题是初始化元素的个数超过了定义的个数
    C的问题是将一个字符串的首地址赋值给一个char变量
    D的问题是将字符串的首地址赋值给int类型数组肯定不行类型不一样。
    所以选D

    22.设有以下结构体类型说明和变量定义,则变量a在内存中所占的字节数是 32 。(VC环境中)
    struct stud
    {char num[6];
    int s[4];
    double ave;
    }a;
    解析:char num[6]占字节数为6+2=8;int s[4]为4*4=16;double ave为8;
    所以a所占字节数为8+16+8=32。

    23.已定义以下函数(D)
    fun(char *p2, char *p1)
    { while((*p2=*p1)!=’\0’){p1++;p2++;}
    }
    A: 将p1所指字符串复制到p2所指内存空间
    B: 将p1所指字符串的地址赋给指针p2
    C: 对p1和p2两个指针所指字符串进行比较
    D: 检查p1和p2两个指针所指字符串中是否有’\0’

    解析:将p1所指字符串复制到p2所指内存空间,直到遇到’\0’结束循环。

    24.下面能正确进行字符串赋值操作的是 (C)

    A: char s[5]={“ABCDE”};
    B: char s[5]={ ′A′, ′B′, ′C′, ′D′, ′E′};
    C: char *s;s=“ABCDE”;
    D: char *s;char a; scanf("%s",&s);
    解析:A. char s[5]={“ABCDE”}; “ABCDE"占用空间是6字节,超出s的长度了
    B. char s[5]={ ′A′, ′B′, ′C′, ′D′, ′E′}; 没有字符串结束的终结符,s不能当字符串使用
    C. char *s;s=“ABCDE”; 正确
    D. char *s;char a; scanf("%s",&s); s还是个野指针

    25.已定义以下函数:

      int  fun(int  *p){return  *p;}
      fun函数返回值是 ( C  )
    

    A: 一个整数
    B: 形参p的地址值
    C: 形参p中存放的值
    D: 不确定的值
    解析:返回的数据类型是整型,返回值是*p,即形参p中存放的值。

    26.p1和p2是指向同一个字符串的指针变量,c为字符变量,则以下不能正确执行的赋值语句是( B)

    A: c=*p1+*p2
    B: p2=c
    C: p1=p2
    D: c=*p1 *(*p2)
    解析:A项 *(取内容符) 将p1 p2指向的变量的值的和赋给c是可以的。
    B项 c是字符变量 p2是指针变量 ,指针变量只能付地址 改为p2=&c是可以的。
    C项 指针就是地址p1 和p2是可以相互赋值的。
    D项 是取其内容运算不是指针运算,是对的

    27.如果x是整型变量,则合法的形式是( D )。
    A: &(x+5)
    B: *x
    C: &*x
    D: *&x
    解析:A.&(x+5) //&表示取地址,后面应该是变量名,不能是表达式。
    B.*x   //*后面应该是指针变量,而x不是。  
    C.&*x  //后面应该是指针变量,而x不是。  
    D.
    &x //相当于x

    28.若有以下定义,则赋值正确的是( C )。
    int a ,b , *p;
    float c, *q;

    A: p=&c
    B: q=p
    C: p=NULL
    D: q=new int
    解析:A选项p和c是不同的类型
    B选项p和q是不同的类型
    C选项正确,p = NULL; :p是一个指针,但它不指向任何变量,多以答案对的。也就是暂时先不给它赋值,以后再赋值。
    D选项 语法错误,new是关键字

    29.若有说明:char language[]={“FORTRAN”,”BASIC”,”PASCAL”,”JAVA”,”C”};
    则表达式
    language[1]>*language[3]比较的是______C________。

    A: 字符F和字符P
    B: 字符串BASIC和字符串JAVA
    C: 字符B和字符J
    D: 字符串FORTRAN和字符串PASCAL
    解析:在我们认为是对字符串BASIC与JAVA进行比较,在运行过程中它先读入字符串的第一个字母,进行比较,如果一样就再读下一个字母,因此这里比较的是B与J

    30.若int i=10;执行下列程序后,变量i的正确结果是( D)
    switch(i){
    case 9:i+=1;
    case 10:i+=1;
    case 11:i+=1;
    default:i+=1;
    }

    A: 10
    B: 11
    C: 12
    D: 13
    解析:这个题有个坑,switch case语句,一句case后面如果没加break的话,就会继续执行下面的语句;
    这个题就是从 case10开始一直往下执行后面的语句,最后i=13.

    展开全文
  • 错题集

    2019-12-30 17:52:50
    解析:s结构体类型名,s a定义了a为一个结构体变量 2.表达式10!=9的值是true。 (F) 解析:在c语言中正确为1,错误为0;所以其值是 1 3.若函数调用时的实参为变量时,以下关于函数形参和实参的叙述中正确的是...
  • (A) 可用S定义结构体变量 (B) 可用T定义结构体变量 (C) S是struct类型的变量 (D) T是struct类型的变量========书上说Typedef语句的作用仅仅是用“标识符”来代表已存在的“类型名”,并未产生新的数据类型,原有类型...
  • //定义学生信息的结构体类型 typedef struct { int Id; char courseNo[10]; //课程编号 char courseName[20];//课程名 double a; // 课程学分 double b; // 平时成绩 double c; // 实验成绩 ...
  • 正确答案应该是四字节对齐,因为起始地址应该按照结构体中最大类型的大小对齐。 2 请问以下说法哪个是正确的: 对于选项A,如果定义了有参数的构造函数时,编译器不再提供无参数的默认构造函数。 选项B:拷贝...
  • 其中结构体类型定义如下: struct stu { char ID[12];//学号 char name[20];//姓名 int c1;//语文成绩 int c2;//数学成绩 int c3;//英语成绩 struct stu * next; } 测试用例如下: 1 ...
  • 其中结构体类型定义如下: struct stu { char ID[12];//学号 char name[20];//姓名 int c1;//语文成绩 int c2;//数学成绩 int c3;//英语成绩 struct stu * next; } 测试用例如下: 1 ...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    内容及步骤: 1、 设计一个图的类,采用临接表法进行存储,该图每个结点的数据类型类模板的模板参数进行定义(注:需先设计一个结点类Node); 2、 为该类分别设计一个实现深度优先搜索和广度优先搜索的成员...
  • 我的思路是先定义菜品信息结构体在一个头文件中。在餐厅管理员菜单中我可以录入新菜品并可将其保存在一个菜品信息的文本里面,然后在用户菜单中可查看文本中原有的菜品信息以及新录入的菜品信息。 可是不知道是我...
  • 1、数据结构:结构体类型数组。 2、数据库结构:下表构成该系统的基本数据库。 姓名 学号 课程名称1 课程名称2 ●●●●●● char Char float float 四、测试数据: 学生人数N=10 课程门数M=4 课程名:数学、...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

s定义以下结构体类型struct