精华内容
下载资源
问答
  • for循环初始化多个变量

    千次阅读 2020-08-02 09:05:56
    j++) 表示的写法:int j=1,s=0, 表示定义并初始化变量j 和s 这个s与 double sum =0,s; 中的s是两个变量。 这种写法跟我们平时定义两个同类型变量的写法是一个道理: int i =0,j=0; //i和j都是int变量。 另外,...

     错误写法:

    float fun(int n)
    {
        double sum =0,s;
        for(int i = 1;i<=n;i++)
        {
            for(int j = 1,s = 0;j<=i;j++)
            {
                s+=j;
            }
            sum+=1/s;
        }
        return sum;
    }

    注意这行: for(int j = 1,s = 0;j<=i;j++)

    表示的写法:int j=1,s=0,  表示定义并初始化了变量j 和s   这个s与 double sum =0,s; 中的s是两个变量。

    这种写法跟我们平时定义两个同类型变量的写法是一个道理:

    int i =0,j=0;  //i和j都是int变量。

    另外,

    编译出现"name lookup of '变量名' changed 

    这是因为,在局部作用域嵌套了同名局部变量s

    改正后写法:将j变量也在for循环外定义

    float fun(int n)
    {
        double sum =0,s;
        int j;
        for(int i = 1;i<=n;i++)
        {
            for(j = 1,s = 0;j<=i;j++)
            {
                s+=j;
            }
            sum+=1/s;
        }
        return sum;
    }
    展开全文
  • 全局变量,static变量初始化时间

    万次阅读 2019-04-24 22:04:41
    首先,静态局部变量和全局变量一样,数据都存放在全局区域,所以在主程序之前,编译器已经为其分配好了内存,但在C和C++中静态局部变量初始化节点又有点不太一样。在C中,初始化发生在代码执行之前,编译阶段分配...

    原文 https://www.cnblogs.com/novice-dxx/p/7094690.html

    本次上传主要是关于静态局部变量的初始化问题。

    首先,静态局部变量和全局变量一样,数据都存放在全局区域,所以在主程序之前,编译器已经为其分配好了内存,但在C和C++中静态局部变量的初始化节点又有点不太一样在C中,初始化发生在代码执行之前,编译阶段分配好内存之后,就会进行初始化,所以我们看到在C语言中无法使用变量对静态局部变量进行初始化,在程序运行结束,变量所处的全局内存会被全部回收。而在C++中,初始化时在执行相关代码时才会进行初始化,主要是由于C++引入对象后,要进行初始化必须执行相应构造函数和析构函数,在构造函数或析构函数中经常会需要进行某些程序中需要进行的特定操作,并非简单地分配内存。所以C++标准定为全局或静态对象是有首次用到时才会进行构造,并通过atexit()来管理。在程序结束,按照构造顺序反方向进行逐个析构。所以在C++中是可以使用变量对静态局部变量进行初始化的
    全局变量、文件域的静态变量和类的静态成员变量在main执行之前的静态初始化过程中分配内存并初始化;局部静态变量(一般为函数内的静态变量)在第一次使用时分配内存并初始化。这里的变量包含内置数据类型和自定义类型的对象。
    根据 C++ 标准,全局变量的初始化要在 main 函数执行前完成,常识无疑,但是这个说法有点含糊,main 函数执行前到底具体是什么时候呢?是编译时还是运行时?答案是既有编译时,也可能会有运行时(seriously), 从语言的层面来说,全局变量的初始化可以划分为以下两个阶段(c++11 N3690 3.6.2):

    static initialization: 静态初始化指的是用常量来对变量进行初始化,主要包括 zero initialization 和 const initialization,静态初始化在程序加载的过程中完成,对简单类型(内建类型,POD等)来说,从具体实现上看,zero initialization 的变量会被保存在 bss 段,const initialization 的变量则放在 data 段内,程序加载即可完成初始化,这和 c 语言里的全局变量初始化基本是一致的。

    dynamic initialization:动态初始化主要是指需要经过函数调用才能完成的初始化,比如说:int a = foo(),或者是复杂类型(类)的初始化(需要调用构造函数)等。这些变量的初始化会在 main 函数执行前由运行时调用相应的代码从而得以进行(函数内的 static 变量除外)。

    在这里插入图片描述

    后面再来谈谈另一个问题,假如我们在一个循环中,定义了一个静态局部变量并进行初始化,循环过程中**,编译器怎么知道当前的静态局部变量已经初始化过了呢?**

    这个问题C和C++的处理方式也是不一样的。C中编译器会直接跳过这一个语句,因为在编译的时候已经对静态局部变量进行过分配空间并初始化,所以代码执行过程中根本不需要再次执行而在C++中,编译器会在编译器分配内存后,在全局区域(当前静态局部变量的地址)附近同样分配一块空间,进行记录变量是否已经进行过初始化。之所以说附近是根据编译器不同,处理方式不同导致的。在网上有博客介绍某种编译器(该吧主并没有透露编译器名字),会在当前变量后面的一个字节进行改变,具体上代码:

    展开全文
  • C语言各种变量初始化

    万次阅读 多人点赞 2018-10-07 23:19:00
    数值类变量初始化 整型、浮点型的变量可以在定义的同时进行初始化,一般都初始化为0。 int inum = 0; float fnum = 0.00f; double dnum = 0.00; 字符型变量初始化 字符型变量也可在定义的同时进行初始化...

    数值类变量初始化

    整型、浮点型的变量可以在定义的同时进行初始化,一般都初始化为0

        int  inum  = 0;
        float fnum = 0.00f;
        double  dnum = 0.00;
    

    字符型变量初始化

    字符型变量也可在定义的同时进行初始化,一般初始化为'\0'

    char ch = '\0';  
    

    字符串初始化

    字符串初始化的方法比较多,我这里简单介绍三种,因为字符串本质上是由一个个字符组成的字符数组,所以其初始化的最终目的,就是将字符数组里面的一个个字符都初始化为'\0'

    方法一:使用空的字符串""

    char str[10] = "";
    

    方法二:使用memset

    char str[10];
    memset(str, 0, sizeof(str));
    

    方法三:写一个循环。

    char str[10];
    for(int i = 0; i < 10; i++)
    {
        str[i] = '\0';
    }
    

    这里比较推荐的是第二种初始化方法。也即使用memset进行初始化。

    很多人对memset这个函数一知半解,只知道它可以初始化很多数据类型的变量,却不知道其原理是什么样的,这里做一下简要的说明:memset是按照字节进行填充的。
    先看下面的一段代码:

    int num;
    memset(&num, 0, sizeof(int));
    printf("step1=%d\n", num);
    memset(&num, 1, sizeof(int));
    printf("step2=%d\n", num);
    

    在讨论之前,我们先看一下运行结果

    chenyc@DESKTOP-IU8FEL6:~/src$ gcc -o memset memset.c -g
    chenyc@DESKTOP-IU8FEL6:~/src$ ./memset
    step1 = 0
    step2 = 16843009
    chenyc@DESKTOP-IU8FEL6:~/src$
    

    看到这个运行结果,是不是和你想象中的不一样呢?
    step1 = 0 相信大家都好理解,可 step2 = 16843009 很多人就不能理解了。按照一般的惯性思维,不是应该 = 1 才对么?
    这就是我要说的,memset是按照字节进行填充的。
    我们知道,int 型是4个字节(每个字节有8位),按二进制表示出来就应该是:

    00000000 00000000 00000000 00000000
    

    按照按字节填充的原则,step1 的结果就是将4个字节全部填充0,所以得到的结果仍然是0:

    00000000 00000000 00000000 00000000 
    

    而 step2 则是将每个字节都填充为1 (注意是每个字节,而不是每个byte位) ,所以相对应的结果就应该是:

    00000001 00000001 00000001 00000001
    

    大家可以自己将上面那个二进制数转换成十进制看看,看看是不是16843009
    所以严格来说,memset函数本身并不具有初始化的功能,而是一个单纯的按字节填充函数,只是人们在使用的过程中,扩展出了初始化的作用。

    字符串初始化有一个小窍门,我们知道字符串本质上是字符数组,因此它具有两个特性,

    • 字符串在内存里是连续的,
    • 字符串遇'\0'结束。
      所以我们在初始化的时候,总是愿意给字符串本身长度加1的长度的内存进行初始化。
    char year[4+1];
    memset(year, 0, sizeof(year));
    strcpy(year,"2018");
    

    指针初始化

    一般来说,指针都是初始化为NULL

    int *pnum = NULL;
    int num = 0;
    pnum = &num;
    

    指针是个让人又爱又恨的东西,一般的整形、字符串等,初始化之后就可以直接拿来用了,可指针如果初始化为NULL后,没有给该指针重新分配内存,则会出现难以预料的错误(最最常见的就是操作空指针引起的段错误)。

    在动态内存管理中,由于变量的内存是分配在堆中的,所以一般用malloccalloc等函数申请过动态内存,在使用完后需要及时释放,一般释放掉动态内存后要及时将指针置空,这也是很多人容易忽略的。

    char *p = NULL;  
    p=(char *)malloc(100);  
    if(NULL == p)
    {  
        printf("Memory Allocated at: %x\n",p);  
    }
    else
    { 
        printf("Not Enough Memory!\n");  
    } 
    free(p);  
    p = NULL;   //这一行给指针置空必不可少,否则很可能后面操作了这个野指针而不自知,从而导致出现严重的问题
    

    很多人经常会犯的一个错误,我们知道,在指针作为实参进行参数传递时,该指针就已经退化成了数组,所以很多人就想到用memset来对该指针进行初始化:

    void fun(char *pstr)
    {
      memset(pstr, 0, sizeof(pstr));
      ...
    }
    

    这种写法是不正确的。我们姑且不管指针能不能用memset来进行初始化,指针首先保存的是一个4字节的地址,所以sizeof(pstr)永远只能 = 4,这样的初始化就毫无意义。

    结构体初始化

    结构体的初始化就比较简单了,基本也都是采用memset的方式。

    typedef struct student
    {
        int id;
        char name[20];
        char sex;
    }STU;
    STU stu1;
    memset((char *)&stu1, 0, sizeof(stu1));
    

    关于初始化结构体的长度问题,也即memset的第三个参数,一般来说,传入数据类型和变量名效果是一样的,上例中,下面写法是等价的效果:

    memset((char *)&stu1, 0, sizeof(STU));
    

    但是对于结构体数组的初始化,长度就需要注意一下了,还是以上例来做说明:

    STU stus[10];
    memset((char *)&stus, 0, sizeof(stus)); //正确,数组本身在内存里就是连续的,sizeof取出的就是数组的字节长度
    memset((char *)&stus, 0, sizeof(STU));  //错误,只会初始化第一个STU结构体,后面还有9个STU元素并未初始化
    memset((char *)&stus, 0, sizeof(STU)*10);  //正确,效果与第一个是一样的
    

    有些人习惯将memset的第二个参数写成以下形式:

    memset((char *)&stu1, 0x00, sizeof(stu1));
    

    只要理解了memset是按字节进行填充的,就知道这样写也是正确的,完全没有问题。

    展开全文
  • 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);
    

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

    展开全文
  • vc中for循环中多变量初始化的坑

    千次阅读 2017-06-19 16:08:47
    在vs2013的debug模式中,如果用这样来定义的话, int iSum = 0; for (int j=0,i = 0; j;j++,i++) { iSum += i; iSum += j;...而在变量监视中显示出来的值最是i=3。...那就奇怪了,为什么i=3,赋
  • 基本数据类型数值6类 (long/int/short/byte)(double/float) 非数值2类(char,boolean)下面是默认值:0/0/0/0/0.0/0.0/ /false首先 Java 语言就是这么规定的。然后为什么 Java 语言要这么规定...而成员变量就是类的数...
  • 和j并初始化赋值0,结果不一样。 ``` <title></title> *{ padding:0; margin:0; font-size: 14px; list-style: none; } .wrap{ width:200px; margin: 10px auto; border: 1px solid #ccc;...
  • Go初始化变量的招式

    千次阅读 2018-05-26 19:10:33
    年初的立的各种Flag,已经被我抛到九霄云外去了。2018年已经过去了一半,终于开始了第三篇文章,距离全年30篇的输出计划,仅剩27本...今天先来聊一聊Go中初始化变量的几种方式。 Go中初始化值类型的招式 Golang...
  • C语言变量初始化的值

    千次阅读 2020-10-26 08:24:32
    C语言中,定义局部变量时如果未初始化,则值是随机的,这是为什么呢? 定义局部变量,其实就是在栈中通过移动栈指针来给程序提供一个内存空间和这个局部变量名绑定。因为这段内存空间在栈上,而栈内存是反复使用的...
  • 如果要对两个变量同时在for后面的括号中进行初始化,例如I=1与flag=1,两个表达式中间应用逗号隔开,而不是用分号,但初始化表达式,循环继续条件表达式,循环控制变量增值表达式,这三者之间使用分号隔开。...
  • 关于局部变量初始化

    千次阅读 2018-10-26 15:22:35
    我们经常被告知:在Java语言规定,局部变量必须要先初始化,然后才能使用。为什么呢? 首先 Java 语言就是这么规定的。其实无论成员变量还是局部变量都要初始化。只是JVM帮我们初始化了成员变量。 第一种解释: ...
  • 所谓初始化就是对变量进行赋值。一段程序结束后,操作系统会对其进行内存回收,但是不会清理该空间内存在的遗留数据,该数据成为垃圾数据。所以在给变量分配内存时,很可能这段内存存在着以前其他程序留下的值。 当...
  • for循环中i变量初始化时报错

    千次阅读 2014-10-12 11:17:41
    for循环中i变量初始化时报错
  • javac 中的if-else变量初始化问题

    万次阅读 2018-09-27 17:22:56
    在前几篇文章中我们介绍过了AbstractAssignAnalyzer.visitIf(JCIf),该方法是用来判断在if语句中变量初始化情况的.例如如下代码: public void assgin(){ int c; int a = 0; if(c != 0){ } } 在IDE ...
  • 全局变量初始化

    千次阅读 2014-08-24 20:08:31
    对于例3,情况有点复杂,因为还有一条c++规则:编译器可以选择将一个本应该动态初始化变量静态初始化,条件是它的动态初始化版本没有改变任何其它先前声明的名字空间域的变量,并且动态初始化版本的结果和静态初始...
  • 1,Halcon相关模组初始化时,会初始化 HObject类型变量m_ObjSourceImage,初始化失败,卡在下述代码中 if (m_ObjSourceImage.GetObjClass() !=NULL) { m_ObjSourceImage.GenEmptyObj(); } 2,退出软件时,...
  • 实在知乎上看的答案,感觉很好,就转载一下,原文地址: 为什么全局变量无须初始化,局部变量必须初始化? https://www.zhihu.com/question/30516949Intopass回答一:首先 Java 语言就是这么规定的。然后为什么 ...
  • 对比了官方给的教程之后发现唯一的不同之处就是我的有一个函数的初始化是在变量初始化之前,进行的初始化,在进行相应的知识查询之后,还有请教了师兄之后,发现了自己以前一直没有注意到的问题就是,函数的初始化...
  • 在上一篇博客 Spring源码学习--Bean对象初始化(二)中我们介绍了Bean对象的初始化过程,接下来我们介绍一下对初始化后的Bean的变量初始化的操作流程。 对于Spring对属性值注入的方式,即使我们没有看Spring的...
  • Go语言变量初始化方法 以下四种命名方法是等价的: s := “” var s string var s = “” var s string = “” 那么什么时候用哪种而不用哪种,为什么? 第一种形式最简洁,但只能用在函数内部,不能用在包变量。 ...
  • VC 中 for循环初始化变量

    千次阅读 2012-05-11 21:15:08
    在c89中规定for循环中的变量必须先声明后赋值,既如上所述,且局部变量的声明必须放在所在函数的最前面。在c99中则可以像int i =0 这样直接声明赋值一起。在Vc编译器中同样支持,程序二以.c后缀命名编译后查看得到的...
  • 局部静态变量是如何做到只初始化一次的? 关于编译选项 -Wa,-adlhn参考 http://blog.csdn.net/lanxinju/article/details/5900986     以下内容来自于内网别的高人的回复 可以写个程序测试一下:  ...
  • C语言while循环语句 do while语句 for循环语句

    万次阅读 多人点赞 2019-06-10 14:17:53
    一、循环结构的思想及意义: 知道了循环结构,那么在生活中也一样,我们每天都在重复做着相同的事情,例如:吸气呼气的过程;又如夏天开电扇,电扇一圈一圈的转,这都是在重复。现在大家玩个游戏,一个人A来说一个人...
  • c中for 循环里可以初始化变量

    千次阅读 2011-08-18 20:28:34
    经常 写成 for(int i = 0; i 在虚拟机下的linux平台下运行不能通过, 改成 int i ; for(i = 0; i    ok
  • int a; main() { ...我们所理解的静态变量b,只知道它在上面的函数内部只初始化一次,其实是个假像 ,我要表达的是,事实上b初始化的值,不是在循环体完成的.继续下看. while(1) {  st
  • 我说所有指针使用前都必须初始化,结构体中的成员指针也是一样 有人反驳说,不是吧,以前做二叉树算法时,他的左右孩子指针使用时难道有初始化吗 那时我不知怎么的想不出理由,虽然我还是坚信要初始化的 过了几...
  • memset初始化详解+变量初始化最大值、最小值 计算机是使用二进制进行存储的,每一个二进制称为1位(bit),每8位称为1字节(Byte,B),1024字节称为1千字节(KB),1024千字节称为1兆字节(MB)。 换算关系: 1MB=1024KB 1KB...
  • ARM局部变量初始化

    千次阅读 2013-09-13 14:06:14
    1、函数内部的局部变量如何初始化,如以下程序中的cost_a、const_b、const_c: extern int main( void ) { uint32_t const_a = 0x12345678; uint32_t const_b = 0x87654321; uint32_t const_c = 0x04; ...
  • java接口的初始化

    千次阅读 2018-10-06 12:04:27
    接口初始化的时候编译器仍然会给接口生成一个()的类构造器,用来初始化接口中的成员变量,这点在类的初始化上也有做到。真正不同的地方在于第三点,类的初始化执行之前要求父类全部都初始化完成了,但接口的初始化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 501,016
精华内容 200,406
关键字:

循环变量初始化是什么