精华内容
下载资源
问答
  • 初始化int类型数组data1[ ]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20}先使用任意一种算法对其排序提示用户输入一个数字,应用折半查找函数模板找出它的位置。 #include <iostream> using ...

    初始化int类型数组data1[ ]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20}先使用任意一种算法对其排序提示用户输入一个数字,应用折半查找函数模板找出它的位置。

      #include <iostream>
      using namespace std;
      template<class T>
       //这里使用了冒泡法排序:
      void mySwap(T&x, T&y)//交换x,y的值
      {
          T temp = x;
        	x = y;
        	y = temp;
       }
        
        template<class T>
        void bubblesort(T a[], int n)//用冒泡法对数组a的n个元素进行排序
        {
    	int i = n - 1;
    
    	while (i > 0)
    	{
    		int lastExchangeIndex = 0;
    		for (int j = 0; j < i; j++)
    		    if (a[j+1]<a[j])
    		{     
    				mySwap(a[j], a[j + 1]);
    				lastExchangeIndex = j;
    		}
    		i = lastExchangeIndex;
    	}  
    }
    
    template<class T>
    int BinSearch(const T list[], int n, const T key)//用折半查找法,在元素呈升序排列的数组list中查找值为key的元素
    {
    
    	int low = 0;
    	int high = n - 1;
    	while (low <= high)
    	{
    		int mid = (low + high) / 2;
    	
    		if (key == list[mid])
    			return mid;
    		else if (key>list[mid])
    			low = mid + 1;
    		else
    			high = mid - 1;
    	}
    	return -1;
    }
    
    
    int main()
    {
    	int key, mid, n = 20;
    	int i;
    	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
    	cout << "数组排序后:" << endl;
    	 bubblesort(data1, n);
    	 for ( i = 0; i < 20; i++)
    	 {
    		 cout << data1[i]<<",";
    	 }
    	 cout << endl;
    	 cout << "请输入key:" << endl;
    	cin >> key;
    	cout << key <<"在数组第:"<<BinSearch(data1, n, key)+1 <<"个数字"<< endl;//数组首元素从1开始算起
    }
    

    在这里插入图片描述

    展开全文
  • 初始化 int 类型数组 data 1 []={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20} ,先用任意一种算法对其进行排序,然后提示用户输入一个数字,应用本章的折半查找函数模板找出它的位置。...

    初始化 int 类型数组 data 1 []={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20} ,先用任意一种算法对其进行排序,然后提示用户输入一个数字,应用本章的折半查找函数模板找出它的位置。

    #include<iostream>
    
    using namespace std;
    
    template<class T>
    
    void BubbleSort(T list[], int n)
    {
    	for (int i = 0; i < n - 1; i++)  //冒泡
    	{
    		int t;
    		for (int j = 0; j < n - i - 1; j++)
    		{
    			if (list[j] > list[j + 1])
    			{
    				t = list[j];
    				list[j] = list[j + 1];
    				list[j + 1] = t;
    			}
    		}
    	}
    }
    
    template<class T>
    
    int binSearch(T list[], int n, T key)
    {
    	int begin, mid, end;
    	begin = 0;
    	end = n - 1;
    	while (begin <= end)
    	{
    		mid = (begin + end) / 2;
    		if (key == list[mid])
    			return mid;
    		else if (key > list[mid])
    			begin = mid + 1;
    		else
    			end = mid - 1;
    	}
    	return -1;
    }
    
    int main()
    {
    	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
    	int key, n = 20;
    
    	BubbleSort(data1, n);     //冒泡
    	
    cout << "排序后的数组为:" << endl;
    	for (int i = 0; i < n; i++)
    	{
    		cout << data1[i] << "  ";
    	}
    
    	cout << endl;
    	cout << "请输入所要查找的数字:";
    	cin >> key;
    	cout << "在数组中的位置:"<<binSearch(data1, n, key) << endl;
    }
    

    上一篇:用函数模板方式设计一个函数模板Sort

    展开全文
  • c语言中初始化一个数组In this article, we’ll take a look at how we will initialize an array in C. 在本文中,我们将研究如何在C中初始化数组。 There are different ways through which we can do this, so ...

    c语言中初始化一个数组

    In this article, we’ll take a look at how we will initialize an array in C.

    在本文中,我们将研究如何在C中初始化数组。

    There are different ways through which we can do this, so we’ll list them all one by one. Let’s get started!

    我们可以通过多种方式来做到这一点,因此我们将它们一一列出。 让我们开始吧!



    方法1:使用初始化列表初始化数组 (Method 1: Initialize an array using an Initializer List)

    An initializer list initializes elements of an array in the order of the list.

    初始化列表按列表的顺序初始化数组的元素。

    For example, consider the below snippet:

    例如,考虑以下代码片段:

    
    int arr[5] = {1, 2, 3, 4, 5};
    

    This initializes an array of size 5, with the elements {1, 2, 3, 4, 5} in order.

    这将初始化一个大小为5的数组,其中元素{1、2、3、4、5}顺序排列。

    This means that arr[0] = 1, arr[1] = 2, and so on.

    这意味着arr[0] = 1arr[1] = 2 ,依此类推。

    We don’t need to initialize all the elements 0 to 4. We can even do only from indices 0 to 2.

    我们不需要初始化所有元素0到4。我们甚至只能对索引0到2进行初始化。

    The following code is also valid:

    以下代码也是有效的:

    
    int arr[5] = {1, 2, 3};
    

    But now, arr[4] and arr[5] will still remain garbage values, so you need to be careful!

    但是现在, arr[4]arr[5]仍将是垃圾值,因此您需要小心!

    If you’re using an initializer list with all elements, you don’t need to mention the size of the array.

    如果您正在使用包含所有元素的初始化列表,则无需提及数组的大小。

    
    // Valid. Size of the array is taken as the number of elements
    // in the initializer list (5)
    int arr[] = {1, 2, 3, 4, 5};
    
    // Also valid. But here, size of a is 3
    int a[] = {1, 2, 3};
    

    If you want to initialize all the elements to 0, there is a shortcut for this (Only for 0). We can simply mention the index as 0.

    如果要将所有元素初始化为0,则有一个快捷方式(仅适用于0)。 我们可以简单地将索引称为0。

    
    #include <stdio.h>
    
    int main() {
        // You must mention the size of the array, if you want more than one
        // element initialized to 0
        // Here, all 5 elements are set to 0!
        int arr[5] = {0};
        for (int i=0; i<5; i++) {
            printf("%d\n", arr[i]);
        }
        return 0;
    }
    

    Output

    输出量

    
    0
    0
    0
    0
    0
    

    If you’re using multi-dimensional arrays, you can still initialize them all in one block, since arrays are stored in a row-wise manner.

    如果您使用的是多维数组,由于数组是以行方式存储的,因此仍然可以在一个块中将它们全部初始化。

    
    #include <stdio.h>
    
    int main() {
        int arr[3][3] = {1,2,3,4,5,6,7,8,9};
        for (int i=0; i<3; i++)
            for (int j=0; j<3; j++)
                printf("%d\n", arr[i][j]);
        return 0;
    }
    

    Output

    输出量

    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    

    A similar method can also be used for other datatypes, like float, char, char*, etc.

    类似的方法也可以用于其他数据类型,例如floatcharchar*等。

    
    #include <stdio.h>
    
    int main() {
        // Array of char* elements (C "strings")
        char* arr[9] = { "Hello", [1 ... 7] = "JournalDev", "Hi" };
        for (int i=0; i<9; i++)
            printf("%s\n", arr[i]);
        return 0;
    }
    

    Output

    输出量

    
    Hello
    JournalDev
    JournalDev
    JournalDev
    JournalDev
    JournalDev
    JournalDev
    JournalDev
    Hi
    

    Remember, this method with [1 … 7] = “Journaldev” might not work with all compilers. I work on GCC in Linux.

    请记住,这种[1…7] =“ Journaldev”的方法可能不适用于所有编译器。 我在Linux上开发GCC。

    方法2:使用for循环在C中初始化数组 (Method 2: Initialize an array in C using a for loop)

    We can also use the for loop to set the elements of an array.

    我们还可以使用for循环来设置数组的元素。

    
    #include <stdio.h>
    
    int main() {
        // Declare the array
        int arr[5];
        for (int i=0; i<5; i++)
            arr[i] = i;
    
        for (int i=0; i<5; i++)
            printf("%d\n", arr[i]);
    
        return 0;
    }
    

    Output

    输出量

    
    0
    1
    2
    3
    4
    

    方法3:使用指定的初始化程序(仅对于gcc编译器) (Method 3: Using Designated Initializers (For gcc compiler only))

    If you’re using gcc as your C compiler, you can use designated initializers, to set a specific range of the array to the same value.

    如果将gcc用作C编译器,则可以使用指定的初始化程序将数组的特定范围设置为相同的值。

    
    // Valid only for gcc based compilers
    // Use a designated initializer on the range
    int arr[9] = { [0 ... 8] = 10 };
    

    Note that there is a space between the numbers and there are the three dots. Otherwise, the compiler may think that it is a decimal point and throw an error.

    请注意,数字之间有一个空格,并且有三个点。 否则,编译器可能会认为这是一个小数点并抛出错误。

    
    #include <stdio.h>
    
    int main() {
        int arr[9] = { [0 ... 8] = 10 };
        for (int i=0; i<9; i++)
            printf("%d\n", arr[i]);
        return 0;
    }
    

    Output (for gcc only)

    输出(仅适用于gcc)

    
    10
    10
    10
    10
    10
    10
    10
    10
    10
    

    We can also combine this with our old initializer list elements!

    我们也可以将其与旧的初始化列表元素结合起来!

    For example, I am setting only array index arr[0], arr[8] as 0, while the others are designated initialized to 10!

    例如,我仅将数组索引arr[0], arr[8]为0,而将其他数组都初始化为10!

    
    #include <stdio.h>
    
    int main() {
        int arr[9] = { 0, [1 ... 7] = 10, 0 };
        for (int i=0; i<9; i++)
            printf("%d\n", arr[i]);
        return 0;
    }
    

    Output

    输出量

    
    0
    10
    10
    10
    10
    10
    10
    10
    0
    


    结论 (Conclusion)

    In this article, we learned how we could initialize a C array, using different methods.

    在本文中,我们学习了如何使用不同的方法初始化C数组。

    For similar articles, do go through our tutorial section on C programming!

    对于类似的文章,请阅读我们有关C编程的教程部分



    翻译自: https://www.journaldev.com/39020/initialize-an-array-in-c

    c语言中初始化一个数组

    展开全文
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活使用,然而,在我们实际应用中,每一种变量进行一次声明,再结合起来...

    渣渣c的c语言学习之路

    1.关于c语言的结构体:

    首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活使用,然而,在我们实际应用中,每一种变量进行一次声明,再结合起来显然是不太实际的,类如一位学生的信息管理,他可能有,姓名(char),学号(int)成绩(float)等多种数据。如果把这些数据分别单独定义,就会特别松散、复杂,难以规划,因此我们需要把一些相关的变量组合起来,以一个整体形式对对象进行描述,这就是结构体的好处。

    2首先我们要了解一些小知识

    2.1**只有结构体变量才分配地址,而结构体的定义是不分配空间的。**
    2.2结构体中各成员的定义和之前的变量定义一样,但在定义时也不分配空间。
    2.3结构体变量的声明需要在主函数之上或者主函数中声明,如果在主函数之下则会报错
    2.4c语言中的结构体不能直接进行强制转换,只有结构体指针才能进行强制转换
    2.5相同类型的成员是可以定义在同一类型下的
    列如

    
    struct Student
    { 
    	int number,age;//int型学号和年龄
    	char name[20],sex;//char类型姓名和性别
    	float score;
    }

    最后的分号不要忘了 有的编译器会自动加上,因此有的同学就会不注意。

    3关于结构体变量的定义和引用

    在编译时,结构体的定义并不分配存储空间,对结构体变量才按其数据结构分配相应的存储空间

    
     struct Book
     { 
     	char title[20];//一个字符串表
    
    示的titile 题目
    	char author[20];//一个字符串表示的author作者
     	float value;//价格表示 
     };//这里只是声明 结构体的定义 
    struct Book book1,book2;//结构体变量的定义 分配空间
    
    book1.value;//引用结构体变量
    

    定义结构体变量以后,系统就会为其分配内存单元,比如book1和book2在内存中占44个字节(20+20+4)具体的长度你可以在你的编译器中使用sizeof关键字分别求出来。
    列如

    当然,要注意一点:用sizeof关键字求结构体长度时,返回的最大基本类型所占字节的整数倍 比方说我们上面求得的为44 为 float(4个字节)的整数倍,
    但是我们把title修改为title[22]; 这时正常长度为46 ,但是你会发现实际求得的为48,(4的整数倍)

    这就涉及到结构体的存储

    1结构体整体空间是占用空间最大的成员(的类型)所占字节数的整数倍。

    2.结构体的每个成员相对结构体首地址的偏移量(offset)都是最大基本类型成员字节大小的整数倍,如果不是编译器会自动补齐,

    关于这个我们简单介绍下:

    1.偏移量----偏移量指的是结构体变量中成员的地址和结构体变量首地址的差。即偏移字节数,结构体大小等于最后一个成员的偏移量加上他的大小,第一个成员的偏移量为0,

    struct S1
    {
        char a;
    
        int b;
    
        double c;
    };
    

    这里char a 偏移量为1 之后为int b 因为偏移量1不为int(4)的整数倍,所以会自动补齐,而在 double c 时,偏移量为8 是double(8)的整数倍,所以不用自动补齐 最后求得结构体得大小为 16

    具体看下图:
    在这里插入图片描述
    通过上面的代码同学们应该会有一个简单的认知

    4结构体变量的初始化

    结构体的初始化有很多需要注意的地方,这里我们说明下
    首先是几种初始化的方法
    ps在对结构体变量初始化时,要对结构体成员一一赋值,不能跳过前面成员变量,而直接给后面成员赋初值,但是可以只赋值前面几个,对与后面未赋值的变量,如果是数值型,则会自动赋值为0,对于字符型,会自动赋初值为NULL,即‘\0’

    4.1定义时直接赋值

    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }stu1={"zhaozixuan",'M',12345};
    //或者
    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }struct Student stu1={"zhaozixuan",'M',12345};
    
    

    注意字符为‘ ’ 字符串为""
    4.2定义结构体之后逐个赋值

    stu1.name="王伟";
    stu1.sex='M';
    stu1.number=12305;
    //也可用strcpy函数进行赋值
    strcpy(stu1.name,"王伟");
    
    

    4.3定义之后任意赋值

     struct Student stu1={
      .name="Wang",
      .number=12345,
      .sex='W', 
     };//可以对任意变量赋值
    

    这样写的好处时不用按照顺序来进行初始化,而且可以对你想要赋值的变量直接进行赋值,而不想赋值的变量可以不用赋值

    需要注意的是如果在定义结构体变量的时候没有初始化,那么后面就不能全部一起初始化了;

    等下结构体数组初始化时我们还会有一个讲解

    这里我们顺带提一下typedef说明结构体类型


    这里的BOOK就相当于struct book的一个别名一样,用它来定义结构体变量非常简便
    主要也是考二级要用到,所以我们简单介绍下

    5结构体变量的引用(输出和输入)

    5.1结构体变量的赋值用scanf赋值和printf输出时跟其他变量操作一样
    但是有几点需要注意
    (1) .是运算符,在所有运算符优先级中最高
    (2)如果结构体的成员本身是一个结构体,则需要继续用.运算符,直到最低一级的成员。

    struct Student
    {	char name[20];
    	char sex;
    	int number;
    	struct Date
    	{
    		int year;
     		int month;
     		int day;
    	}birthday;
    
    }stu1;
    printf("%d",stu1.birthday);//这样子是错误的,因为birthday也是一个结构体变量
    scanf("%d",&stu1.birthday.month);//正确
    

    (3)可以引用接头体变量成员的地址,也可以引用结构体变量的地址:

    printf("%o", student);(输出student的首地址)(%o 按八进制输出)

    6结构体数组及其初始化(重点)

    这里我们简单说下,具有相同类型的结构体变量组成数组就是结构体数组

    结构体数组与结构体变量区别只是将结构体变量替换为数组

    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }stu1[5]={
    	 {"zhaozixuan",'M',12345},
    	 {"houxiaohong",'M',12306},
    	 {"qxiaoxin",'W',12546},
    	 {"wangwei",'M',14679},
    	 {"yulongjiao",'W',17857}
    };
    stu1[3].name[3]//表示stu1的第三个结构变量中姓名的第五个字符
    //若初始化时已经是结构体数组全部元素[]中的数可以不写如stu1[]=
    

    注意结构体数组要在定义时就直接初始化,如果先定义再赋初值是错误的
    比如:

    struct Student stu1;
    stu1[3]={
      {"zhaozixuan",'M',12345},
      {"houxiaohong",'M',12306},
      {"qxiaoxin",'W',12546}
      };
      
    

    这样子是错误的,

    这里我在写的时候遇到一些问题,还是结构体数组初始化的问题,折腾了下解决了,给大家分享下
    对于数组初始化时
    比如

    char str[20];
    str="I love you";/* 这样会修改数组的地址,但是数组的地址分配之后是不允许改变的 */
    
    

    在第一条语句中 str就已经被定义成数组而在C99标准中不允许将字符串(实际上是一个指针变量) 赋值给数组,所以如果我们直接赋值是错误的

    那么怎么弄呢
    这里提供3种方法

    1.定义数组时直接定义
    char str[20]=“I love you”;

    2.用strcpy或者memset函数进行复制
    char str[20];
    strcpy(str,“I love you”);
    再用到memset函数时,出现了一些问题
    对于memcset函数简单介绍下

    memset
    void *memset(void *s,int c,size_t n)
    作用:将已开辟内存空间s的首n个字节的值设为值c。

    char str[20];
    memset(str,'a',20);
    

    如果是字符类型数组的话,memset可以随便用,但是对于其他类型的数组,一般只用来清0或者填-1,如果是填充其他数据就会出错

    int str[10];
    memset(str,1,sizeof(str));//这样是错误的
    
    

    这里我们说下这个错误,

    首先我们要知道memset在进行赋值时,是按字节为单位来进行赋值的,每次填充的数据长度为一个字节,而对于其他类型的变量,比如int,占4个字节 所以sizeof(str)=40; 而用memset赋值时,将会对指向str地址的前40个字节进行赋值0x01(00000001) 的操作,把0x00000000赋值4次0x01操作变为0x01010101(00000001000000010000000100000001)

    相当于给“前10个int”进行了赋值0x01010101的操作 对应十进制的16843009
    所以会出很大的错误

    这里请务必要注意,但是如果是清零一个数组用memset还是很方便的
    简单使用的话同学们用strcmp函数就行

    3用指针(注意内存分配)
    char *str;
    str=“I love you”;

    这两句话的本质是,在内存中开辟一段内存空间,把"I love you"放进这段内存空间,然后把这段内存空间的地址交给str,由于str是变量,所以给它赋值是合法的。

    请注意,在我们进行数组初始化的时候如果定义的数组过长,而我们只初始化了一部分数据,对于未初始化的数据如果是数值型,则会自动赋值为0,对于字符型,会自动赋初值为NULL,即‘\0’ 即不足的元素补以默认值
    这里我们在4小节中也提到了
    比如

    int str[10]={1};//这里只是把str的第一个元素赋值为1,其他元素默认为0
    
    



    7结构体与指针

    我们知道,指针指向的是变量所占内存的首地址,在结构体中,指针指向的是结构体变量的起始地址,当然也可指向结构体变量的元素
    这里我们分为三部分
    7.1指向结构体变量的指针

    定义形式一般为
    struct 结构体名* 指针名;
    比如: struct Student* p;

    struct Student
    {	
    	char cName[20];
     	int number;
     	char csex;  
    }student1;
    struct Student*p;
    p=&student1;
    //若为结构体数组则
    struct Student stu1[5];
    struct Student*p;
    p=stu1;//因为stu1为结构体数组而p=stu1直接是指向stu1的首地址,就不用再加&符
    
    

    用结构体指针变量访问结构体变量成员有以下两种方式:
    (*p).cName //这里的括号不能少,在5.1中有提到
    p->cName

    简单来说以下三种形式是等价的

    p->cName
    (*p).cName 
    student1.cName
    p->cName //可以进行正常的运算
    

    p->number++; 是将结构体变量中number的值进行运算,然后再加一,
    这里要注意下,等下在7.2中会有比较

    7.2指向结构体数组的指针

    7.1中我们已经提到结构体数组指针的命名,这里我们仅对一些知识点做下介绍
    这里我们接着来说结构体数组指针
    在我们想要用指针访问结构体数组的第n个数据时可以用

    struct Student stu1[5];
    struct Student*p;
    p=stu[n];
    (++p).number//是指向了结构体数组下一个元素的地址
    
    

    7.3结构体成员是指针类型变量
    比如

    struct Student
    {
     	char* Name;//这样防止名字长短不一造成空间的浪费
     	int number;
     	char csex;  
    }student1;
    
    

    在使用时可以很好地防止内存被浪费,但是注意在引用时一定要给指针变量分配地址,如果你不分配地址,结果可能是对的,但是Name会被分配到任意的一的地址,结构体不为字符串分配任何内存存储空间具有不确定性,这样就存在潜在的危险,

    struct Student
    {
     	char* Name;
     	int number;
     	char csex;  
    }stu,*stu;
    
    stu.name=(char*)malloc(sizeof(char));//内存初始化
    

    这里我们说一下,同学们看书的时候一般不会看到,
    如果我们定义了结构体指针变量,他没有指向一个结构体,那么这个结构体指针也是要分配内存初始化的,他所对应的指针类型结构体成员也要相应初始化分配内存

    struct Student
    {
     	char* Name;
     	int number;
    	char csex;  
    }stu,*stu;
    stu = (struct student*)malloc(sizeof(struct student));./*结构体指针初始化*/
      stu->name = (char*)malloc(sizeof(char));/*结构体指针的成员指针同样需要初始化*/  
    
    

    7.4二叉树遍历算法
    二叉树的二叉链表类型定义如下:
    typedef struct btnode {
    datatype data;
    struct btnode *lchild,*rchild;
    };
    这里我们仅仅提出以下,因为涉及到链表,感兴趣的同学可以去学习下(二级要用),
    7.5结构体作为函数参数

    首先我们要注意的一点,使用结构体变量作为函数参数的时候,采取的是值传递的方式,将结构体所占内存单元的内容全部传递给形参,并且形参必须也要是同类型的结构体变量,在使用时,会自动创建一个结构体变量作为原变量的副本,并且也需要占内存,并且在调用期间如果修改(形参)结构体中成员的值,修改值是无效的

    而如果用指针作为实参,传递给函数的形参,这时候传递的是结构体的地址,形参所指向的地址就是结构体变量的地址,这时候进行修改的话是可以修改的,这正是指针的精华所在

    在这里我们再提供几种互换两个结构体的方法

    struct Student
    {
     char cName[20];
     int number;
     char csex;  
    }student1,student2;
    struct Student student1={"Wang",12345,'W'};
    struct Student student2={"Zhao",54321,'M'}; 
    struct Student*stu1=&student1;
    struct Student*stu2=&student2;
    
    struct Student *student3;
    student3=stu1;
    stu1=stu2;
    stu2=student3;//互换地址
    
    2对于同类型结构体直接互换值就行
    struct stu student3;
    student3=student1;
    student1=student2;
    student2=student3;
    //这里也可以写成应strcmp函数互换
    
    3memcpy()函数进行互换
    
    
    4比较笨的方法: 用for循环互换
    

    最后提下memset清空结构体

    struct Student
    {
     char cName[20];
     int number;
     char csex;  
    }stu1;
    
    一般情况下,清空str的方法:
      str.cName[0]='\0';
      str.csex='0';
      str.number=0;
      但是我们用memset就非常方便:
      memset(&str,0,sizeof(struct Student));
      如果是数组:
      struct Student stu[10];
      就是
      memset(stu,0,sizeof(struct Student)*10);
    

    整理不易,点个赞再走呗!

    展开全文
  • 数组属于引用数据类型,在使用前必须初始化,否则会报NullPointerException(空指针异常:运行时异常) 一维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] ...
  • 文章目录1 一维数组1.1 数组的定义1.2 数组初始化1.2.1 数组动态初始化1.2.2 数组静态初始化1.3 数组空间的开辟1.3.1数组引用传递 1 一维数组 1.1 数组的定义   在Java中,可以用如下格式定义一个数组:数据...
  • 数组的声明、初始化、赋值

    千次阅读 2018-10-19 23:23:51
    一、数组的声明 #include&lt;stdio.h&gt; int main(){ float candy[365];//通过声明告诉编译器数组元素...//内含50个int类型元素的数组 /*数组的编号从0开始,因此candy[0]代表数组第一个元素 candy[3...
  • 使用STL标准模板库之后,编程时已经很少使用数组和指针,相反,多使用序列容器vector代替之。 (std::vector&lt;int&gt;,构造函数接受const std::vector&lt;int&gt; &amp;vec,拷贝用this-&...
  • 使用memset初始化数组,该函数是用来给某一块内存空间进行赋值的;包含在<string.h>头文件中,可以用它对一片内存空间逐字节进行初始化; 原型为 : void *memset(void *s, int v, size_t n); 这里s可以是...
  • Java中数组的定义及初始化

    千次阅读 2018-10-23 00:14:18
    1动态初始化(声明并开辟数组)1.2 静态初始化2. 引用传递3. 二维数组的基本了解4. 数组与方法的互操作4.1 方法接收数组4.2 方法返回数组4.3 方法修改数组5. Java对数组的支持5.1 排序5.2 数组的拷贝5.2.1 数组的...
  • C++ - new - 动态数组 - 初始化

    千次阅读 2020-03-01 21:18:08
    数组的动态初始化 在代码的时候看到了new初始化的一些问题,查阅了相关文档总结如下。可直接阅读结论部分,文档内内容在下面。 结论: int *p = new int[10]; // 每个元素都没有初始化 int *p = new int[10] (); // ...
  • ajax 传int[] 数组

    2019-06-05 11:56:48
    转自:https://blog.csdn.net/ShenDi12345/article/details/79173963 https://www.cnblogs.com/perallina/p/5895144.html 1.前台js部分 function ok(){ var arr=[];//代表数组 $.ajax({ type: 'P...
  • 深入理解数组的定义和初始化

    千次阅读 2018-08-09 08:42:21
    下面就数组的定义和初始化的一些特性做一些探讨。 定义数组  通常,定义一个数组,只需要写出数组类型数组名、数组大小即可。这是每一个写程序的人都知道的。这里需要说明一点,数组的大小,不一定非得是整型...
  • Go语言 数组初始化和基本操作

    千次阅读 2018-11-11 23:41:30
    // 数组同一类型的集合 var arr [50]int // 1 赋值 // 操作数组,下标从0开始,索引从0到len()-1 for i := 0; i &lt; len(arr); i++ { arr[i] = i + 1 fmt.Printf("arr[%v] = %v\n", i, a...
  • 指定初始化数组元素03. 指定初始化结构体成员变量04. Linux内核中应用05. 初始化总结06. 附录 01. 初始化概述 在标准 C 中,当我们定义并初始化一个数组时,常用方法如下: int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8...
  • C++ Vector数组初始化(一维,二维)

    千次阅读 多人点赞 2019-11-06 11:10:48
    Vector数组快速声明与初始化 一维 以int类型为例子 设置数组长度的默认初始vector<int> data(N); N为默认数组长度,默认初始值为0 设置数组长度的给定值初始vector<int> data(N,value); N为...
  • 1.一维数组初始化: 静态初始化int[] a = {1,2,3,4}; 动态初始化: String books = new String[3]; books[0] = "活着"; books[1] = "追风筝的人"; books[2] = "茶花女"; 2. 二维数组初始化: 二维数组实际上...
  • 【问题1】C++类中的数据成员能否在定义类的时候就初始化?(注:在最新的C++11标准中已经支持在定义类的时候进行成员初始化。但初始化不是在编译时发生,这只是语法糖,而成员变量是在默认构造函数中初始化的) ...
  • 数组的定义及初始化

    2017-10-27 17:21:12
    一、一维数组的定义及初始化方式1> int[] array1=new int[5]; //初始化为该类型的默认值 2> int[] array2=new int[]{1,2,3,4,5}; 3> int[] array3={6,7,8,9,10}; 二、相关操作1> System.out.println(Arrays.equals...
  • 【嵌入式开发】C语言 指针数组 多维数组

    万次阅读 热门讨论 2014-03-19 01:52:05
    ① 模拟C语言中内存分配策略 ; ② 使用 字符指针 和 字符数组 实现 字符串 拷贝 和 比较 ; ③ 指针数组, 数组中的元素 指向一个一维数组 ;...⑤ 指针数组 和 二维数组 , 指针数组用于存储长度可变的数组, 更节省空间 ;
  • 场景 1.我们知道栈上创建的POD数组可以使用 {0}初始化, > 第3.9部分, 数组. 如果指定了维数 那么初始化...2.对于C++ new 出来的free store数组new int[5] 如何进行初始化是一个头疼的问题. 因为大部分书里也没提到
  • 编写一个程序,初始化一个 double 类型数组,然后把该数组的内容 拷贝至 3 个其他数组中(在 main()中声明这 4 个数组)。使用带数组表示法的 函数进行第 1 份拷贝。使用带指针表示法和指针递增的函数进行第 2 份...
  • 先来个常识,字符串数组的构造函数有三种,分别是: String[] array = new String{5]; String[] array = new String[]{"11","33","2323"}; String[] array = new {"ee","rr",erer"}; 用上述代码均可以声明一个...
  • 数据类型 数组名[数组元素数量]; 注意:数组元素数量一定是常数、常量、整型,不能是变量!   数组:一组具有相同类型的变量的集合。 ...数组名:标识这组相同的数据...全部初始化int a[5]={12,23,45,35,9},int ...
  • 例如:在定义这个int类型中,类型int并不占用空间,变量a占用系统所分配的4个字节大小的空间。因此,在结构体变量定义中,如在定义类型时,系统并未分配空间,只有定义一个类型变量,系统才会分配相应大小的空间。...
  • 一、C和C++中的结构体不同 1.C++对struct关键字进行了增强:如下代码 struct info { int a; };...int main(int argc,char *argv[]) ... info data;...2.C++中可以使用构造函数对结构体成员进行初始化,而C中...
  • 本博文源于Java基础,Java数组透露着对象的气息,因此掌握类的构造也就掌握和适应数组的构造
  •  在Windows下,Data Segment的所允许的空间大小取决于剩余内存的大小,也就是说,如果电脑剩余8G内存的话,int类型的二维数组甚至可以开到46340*46340的大小;  而Stack的空间只有2M!!也就是2*1024*1024=...
  • 目录 一、顺序表定义及特点 1.顺序表定义 2.顺序表特点 二、顺序表定义 三、顺序表插入运算 ...用数组存储线性表,称作线性表的顺序存储结构或顺序映像,用这种方法存储的线性表称作顺序表。 2.顺序...
  • 如果您省略掉了数组的大小,数组的大小则为初始化时元素的个数。 int arr[5] = {1, 2, 3}; 方法2: int n[ 10 ]; // n 是一个包含 10 个整数的数组 // 初始化数组元素 for ( int i = 0; i < 10; i++ ) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 177,217
精华内容 70,886
关键字:

初始化int类型数组data