精华内容
下载资源
问答
  • // 输出结果的分隔符, 比如: 如果想要换行输出, 可以改为: \n // 有个特殊例外, 如果设置为 gop, 则会输出 "xxx", "xxx" 样式 "OutputSeparator": "gop", // IP 或 IP 文件...
  • 运行下面这段程序: public static void main(String args[]){ double...抛开无限循环不说,这个程序直观看来应该是输出除了10.0以外,大于等于0形如0.9,1.1这样数字。 然而运行结果中出现了10.0 好奇怪,...

    运行下面这段程序:

    public static void main(String args[]){
    double i;
    for(i=0; i!=10; i+=0.1){
    System.out.printf("%f\n",i);
    }
    }

    抛开无限循环不说,这个程序直观看来应该是输出除了10.0以外的,大于等于0的形如0.9,1.1这样的数字。

    然而运行结果中出现了10.0

    好奇怪,debug的时候发现,不是每次自加0.1都是正好加上去0.1,有时候会多一点有时候又会少一点。

    有图为证:

     

    没想明白这是怎么回事,难道是浮点数计算误差?

    转载于:https://www.cnblogs.com/RainandTears/p/4940498.html

    展开全文
  • 最近写了一代码 ...所以得到32位二进制应该为 0100 0001 0001 0000 0000 0000 0000 0000,转换为十进制是 1091567616,但程序的运行结果是 0。 去网上查了一下资料以后发现变量在printf函数中会发生上转

    最近写了一段代码

    #include<stdio.h>
    
    int main(){
        float a = 9.0;
        printf("%d",a);
        return 0;
    }

    根据浮点数的转换公式:得出符号位为 0,有效位为 1.001,指数为 3。

    所以得到的32位二进制应该为 0100 0001 0001 0000 0000 0000 0000 0000,转换为十进制是 1091567616,但程序的运行结果是 0。

    去网上查了一下资料以后发现变量在printf函数中会发生上转,即float变量在入栈的时候作为一个double变量压入了8个字节。所以存储的数据应该是 0100 0000 0010 0010 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000。又因为我的电脑是小端序的,存储数据的时候数据的低位放在内存低位。因此按格式符%d输出的时候,从内存低位读取4个字节后得到的是 0000 0000 0000 0000 0000 0000 0000 0000,转换成十进制是 0。

    展开全文
  • 但是必须注意, 求值顺序虽是自右至左,但是输出顺序还是从左至右, 因此得到的结果是上述输出结果。 字符输出函数 putchar 函数 putchar 函数是字符输出函数, 其功能是在显示器上输出单个字符。其一般形式为: ...
  • 4.5请写出下面程序的输出结果: 7 4.6 用下面的scanf函数输入数据,使a=3,b=7,x=8.5,y=71.82,c1=’A’,c2=’a’。问在键盘上如何输入? 7 4.7下面的scanf函数输入数据,使a=10,b=20,c1=’A’,c2=’a’,x=...
  • 而且一般是程序运行了一时间后才出现卡死情况,这两天具体定位了卡住语句,主要是 outputs = self.generator(inputs, reuse=False) 这句话卡住一直不执行,这句话是我在定义计算...
  • 为了增加程序的可读性,可把整型说明符用typedef定义为: typedef int INTEGER 这以后就可用INTEGER来代替int作整型变量类型说明了。 例如: INTEGER a,b;它等效于: int a,b; 用typedef定义数组、指针、结构等...
  • 使用 AutoCAD 技术人员都知道,从 AutoCAD 2000 以后的各个版本, AutoCAD 中命令执行具有以下特性,在一个命令执行没有完成之前就可以切换到另一个图形窗口执行别命令,就像切换到别应用程序。...
  • <p>Vue通过一系列计算之后最终产出的结果是一些指令,比如创建一个DOM元素,移除一个DOM元素,插入到某个位置等。 所以当时做法就简单在创建DOM元素时,用<code>tagName校验是否在黑名单...
  • 一般地,当算法在处理信息时,会从输入设备或数据存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。 算法是独立存在一种解决问题方法和思想。 对于算法而言,实现语...

    算法的概念和特性

    算法是计算机处理信息的本质,因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。一般地,当算法在处理信息时,会从输入设备或数据的存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。

    算法是独立存在的一种解决问题的方法和思想。

    对于算法而言,实现的语言并不重要,重要的是思想

    算法可以有不同的语言描述实现版本(如C描述、C++描述、Python描述等),我们现在是在用Python语言进行描述实现。

    算法具有五大特性:

    1. 输入: 算法具有0个或多个输入
    2. 输出: 算法至少有1个或多个输出
    3. 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成
    4. 确定性:算法中的每一步都有确定的含义,不会出现二义性
    5. 可行性:算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成

    算法效率的衡量

    由于不同的计算机性能不同,所以用算法进行的基本操作的数量来衡量算法的效率

    举一个例子,观察如下的代码,解方程a+b+c=1000;a^2 +b^2 = c^2

    for a in range(1001):
        for b in range(1001):
            for c in range(1001):
                if a + b + c == 1000 and a ** 2 + b ** 2 == c ** 2:
                    print(a, b, c)
    

    这个代码执行最外层的循环需要1000步,第二层的循环需要1000步,第三层的循环需要1000步,最内层循环内部的代码粗略地算作2步,这个程序执行的总步骤数设为T1,则T1 = 1000 ^ 3 * 2;如果把条件改为a+b+c=2000,则总步骤数为T2=2000^3*2.如果把数据的规模设为n,则步骤数可以表示为T(n) = n ^ 3 * 2,这个步骤数称为时间复杂度.由于后面的系数对这个函数的走势没有特别大的影响,所以一般取最核心的部分,例如上面的T(n)可以简化为G(n)=n^3.

    算法完成工作最少需要多少基本操作,即最优时间复杂度;算法完成工作最多需要多少基本操作,即最坏时间复杂度;算法完成工作平均需要多少基本操作,即平均时间复杂度.因此,我们主要关注算法的最坏情况,亦即最坏时间复杂度.

    时间复杂度有几条计算规则:

    1. 基本操作,即只有常数项,认为其时间复杂度为O(1)
    2. 顺序结构,时间复杂度按加法进行计算
    3. 循环结构,时间复杂度按乘法进行计算
    4. 分支结构,时间复杂度取最大值
    5. 判断一个算法的效率时,往往只需要关注操作数量的最高次项,其它次要项和常数项可以忽略
    6. 在没有特殊说明时,我们所分析的算法的时间复杂度都是指最坏时间复杂度

    下面引进一些常见的时间复杂度:

    执行次数函数举例 非正式术语
    12 O(1) 常数阶
    2n+3 O(n) 线性阶
    3n2+2n+1 O(n2) 平方阶
    5log2(n)+20 O(log(n)) 对数阶
    2n+3nlog(2n)+19 O(n*log(n)) nlogn阶
    6n3+2n2+3n+4 O(n3) 立方阶
    2n O(2n) 指数阶

    注意,经常将log2n(以2为底的对数)简写成logn

    常见时间复杂度之间的关系

    所消耗的时间从小到大

    O(1) < O(log(n)) < O(n) < O(n*log(n)) < O(n2)<O(n2log(n)) < O(n3) < O(2n) < O(n!) < O(nn)

    Python内置性能分析

    timeit模块可以用来测试一小段Python代码的执行速度。

    class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=<timer function>)

    Timer是测量小段代码执行速度的类。stmt参数是要测试的代码语句(statment),是一个字符串setup参数是运行代码时需要的设置;timer参数是一个定时器函数,与平台有关。

    timeit.Timer.timeit(number=1000000)

    Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数,默认为1000000次。方法返回执行代码的平均耗时,一个float类型的秒数。

    示例:比较推导式创建列表和加号创建列表的速度

    from timeit import Timer
    def t1():
        l = [i for i in range(1000)]
    
    def t2():
        l = []
        for i in range(1000):
            l = l + [i]
    
    test1 = Timer('t1()', 'from __main__ import t1')
    test2 = Timer('t2()', 'from __main__ import t2')
    print(f'推导式花费{test1.timeit(number=1000)}秒')
    print(f'for循环花费{test2.timeit(number=1000)}秒')
    

    输出结果

    推导式花费0.028509700000000027秒
    for循环花费1.6175822秒
    

    下面介绍字典和列表操作的时间复杂度

    在这里插入图片描述

    上图是列表内置操作的时间复杂度(设某个列表名为list,时间复杂度均指最坏时间复杂度):
    indexx[]指定一个位置取出元素(如list[2],取出第三个元素):时间复杂度O(1)
    index assignment给指定位置的元素复制(如list[2]=3):时间复杂度O(1)
    append在尾部添加元素:时间复杂度O(1)
    pop()从尾部弹出元素:时间复杂度O(1)
    pop(i)弹出第i个元素:步骤数n,最坏的情况,如果i代表列表第一个元素,从最后一个元素一直取到第一个元素,那么时间复杂度为O(n)
    insert(i,item)在指定位置插入元素:时间复杂度为O(n),如果列表长度是n,在头部插入一个元素,首先n个元素往后挪动一位,然后在头部插入元素,总步骤数是n+1,所以时间复杂度是O(n)
    del operator:时间复杂度为O(n),代表逐个删除列表中的元素
    iteration迭代操作:时间复杂度为O(n)
    contains(in)判断某个元素是否在列表中,如3 in list:如果需要遍历列表,则时间复杂度为O(n)
    get slice[x:y]代表取切片,从x开始取,取到y的前一个元素:x和y之间有k个元素,时间复杂度为O(k)
    del slice[x:y]代表删除切片:假设删除第一个元素,则后面的元素全部都要往前挪一位,时间复杂度为O(n)
    set slice代表设置切片:时间复杂度为O(n+k),k代表补充列表的长度
    举例:

    list1 = [1, 2, 3]
    list1[0:3] = [4, 5, 6]
    print(list1)
    

    输出结果

    [4, 5, 6]
    

    这个例子首先删掉了list1中的3个元素,然后将4,5,6补充到list1中,用n代表原列表的长度,k代表补充列表的长度,则时间复杂度为n+k
    reverse代表逆序取出列表中的元素:时间复杂度为O(n)
    concatenate代表将两个列表加到一起:设列表1为list1,列表2为list2,将list2的k个元素放在list1的尾部,且list2的长度为k,则时间复杂度为O(k)
    sort代表排序操作:时间复杂度为O(nlogn)
    multiply代表列表的乘法操作
    举例:

    list1 = [1, 2]
    list2 = list1 * 3
    print(list2)
    

    输出结果

    [1, 2, 1, 2, 1, 2]
    

    假设原列表的长为n,乘以系数k,则时间复杂度为O(nk)

    以上内容的重点是索引indexx[],队尾添加append,弹出pop(i),插入insert(i,item),查找contains(in)

    在这里插入图片描述

    上图是字典内置操作的时间复杂度
    copy代表复制字典,将字典中的所有元素复制一遍
    get item通过键取到值
    set item通过键设置值
    delete item通过键删除值
    contains(in)代表查找,因为键是唯一的,所以只需一步
    iteration代表迭代

    数据结构引入

    **数据结构就是一组数据的组织方式,程序=数据结构+算法

    抽象数据类型(Abstract Data Type,ADT)是把数据类型和数据类型上的运算捆绑在一起进行封装,常用的数据运算有**插入,删除,修改,查找,排序

    展开全文
  • 当算法在处理信息时,会从输入设备或数据存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。 3.算法四大特征:(1)算法至少可以有0个输入,但至少有一个输出;(2)算法...

    第一章     数据结构与算法的基本概念

    1.没有数据结构与算法组织的程序存在以下三个缺点:(1)面对问题没有解决思路,无从下手。(2)没有考虑程序的效率与空间的开销,性能低下。(3)根据别人的程序暂时解决问题,但相对其进行优化时,不知道如何针对性的下手

    2.算法的本质:一种解决问题的思路。算法是计算机处理信息的本质。当算法在处理信息时,会从输入设备或数据的存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。

    3.算法的四大特征:(1)算法至少可以有0个输入,但至少有一个输出;(2)算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成(有穷性);(3)算法中的每一步都有确定的含义,不会出现二义性(确定性);(4)算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成(可行性)。

    4.针对“如果 a+b+c=1000(可以替换为n:问题的规模),且 a^2+b^2=c^2(a,b,c 为自然数),如何求出所有a、b、c可能的组合?”

    (I)初始想法:这样的问题,我们可以考虑采用“枚举abc组合”的方法一个一个去试。在不断的组合试错中找到符合要求的解。这是一种解决这类问题的思想,它实现的计算机语言无关。因此,可以考虑采用均在0~1000范围内遍历a,b,c的各种组合情况,但要把握好三个for遍历循环的内外层嵌套关系。

    (2)优化算法:考虑到输出上述代码运行时间144s(与机型相关),效率太低,于是利用问题的第一个条件(知二求一)可以在a,b确定后定下具体的c值,三个数之间是有一层相对关系的,因此可以用一个基本数据操作代替一层循环,即c=1000-a-b,并因此取消了第一个判断条件。经过两种代码的对比发现效率与算法有关

    # -*- coding:utf-8 -*-
    import time
    start_time=time.time()
    for a in range(1001):   #第一种思想代码
        for b in range(1001):
            for c in range(1001):
                if a+b+c==1000 and a**2+b**2==c**2:
                    print('a={1},b={2},c={3}'.format(a,b,c))
    '''
    for a in range(1001):   #第二种思想代码
        for b in range(1001):
            c=1000-a-b
            if a**2+b**2==c**2:
                print('a={1},b={2},c={3}'.format(a,b,c))
    '''
    print('程序结束!')
    end_time=time.time()
    print('运行耗时:%d'%(end_time-start_time))
    #补充:上句中通过%d将输出值保留整数,中间用%将字符串与数值计算结果连接

            另外,当问题规模发生变化时,其解决思路并未发生变化,所以学习算法的核心在于学习其思想。

    5.有上述实践可知,实现算法程序的执行时间可以反应出算法的效率,即算法的优劣。但单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的!因为这个运行时间跟计算机的机型与配置情况有关。虽然每台机器运行的总时间不同,但执行基本操作的步骤数量是一致的。因此将程序执行基本操作的步骤的总数记为时间复杂度,用来描述两个算法的优劣

            对于以上两种算法,(1)T(n)=n*n*n*(8+1+1)=10n^3,其中外面三层循环为嵌套结构采用乘法,另外条件判断句中共8步(第一步:a+b+c第二步:a+b+c==1000第三步:a^2第四步:b^2第五步:c^2第六步:a^2+b^2第七步:a^2+b^2==c^2第八步:a+b+c==1000 and a^2+b^2==c^2),''.format()运算一步,print()输出一步。(2)T(n)=n*n*(1+5+1+1)=8n^2。

           对于算法的时间复杂度进行特别具体的细致分析虽然很好,但在实践中的实际价值有限。对于算法的时间性质和空间性质,最重要的是其数量级和趋势。一般而言,常系数不影响时间复杂度随问题规模的变化,只会影响其陡峭性。所以常将常系数(视作1)与常数项(视作0)忽略,这时得到的函数就叫做T(n)的渐进函数,即其大O表示法。至此,在分析时间复杂度时,可以将与问题规模n无关的步骤看做常数项,也就是基本操作,上面的if a+b+c==1000 and a**2+b**2==c**2与print('a={1},b={2},c={3}'.format(a,b,c)),以及 c=1000-a-b,if a**2+b**2==c**2与print('a={1},b={2},c={3}'.format(a,b,c))均为基本操作,每步时间复杂度可看做O(1)。(将T(n)去常数项与常系数,找到里边相比其他项耗时最多的那项即得渐进函数g(n)。)

    6.时间复杂度的分类:(1)算法完成工作最少需要多少基本操作,即最优时间复杂度,这是情况最特殊最理想的一种情况,不做深入研究,其实际意义不大;(2)算法完成工作最多需要多少基本操作,即最坏时间复杂度,它提供了一种保证,表明算法在此种程度的基本操作中一定能完成工作。(3)算法完成工作平均需要多少基本操作,即平均时间复杂度,但这种衡量并没有保证,不是每个计算都能在这个基本操作内完成。因此对于以上三种,主要关注(最坏)时间复杂度

    7.时间复杂度的基本计算规则:(1)基本操作,即只有常数项,认为其时间复杂度为O(1);(2)顺序结构(基本步骤累加,比连续执行2次print()),时间复杂度按加法进行计算;(3)循环结构,时间复杂度按乘法进行计算;(4)分支结构,时间复杂度取最大值(考虑多个分支中最坏的那个分支,符合最坏时间复杂度的定义);(5)判断一个算法的效率时,往往只需要关注操作数量的最高次项,其它次要项和常数项可以忽略;(6)在没有特殊说明时,我们所分析的算法的时间复杂度都是指最坏时间复杂度。因此前面两种算法的时间复杂度为O(n^3)与O(n^2)。

    8.常见时间复杂度之间的关系:所消耗的时间从小到大排列为:

    O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^2logn)<O(n^3)<O(2^n)<O(n!)<O(n^n)

    9.对于python中的列表,其尾部追加函数append(),任意位置插入函数insert(),虽然调用时只有一句,但不属于基本操作步骤,其封装于函数体中的代码才能体现其具体的时间复杂度。因此在python中,常常要调用内置类型性能分析模块timeit测试一段代码的执行速度。

    具体实现方法:导入timeit模块中的计时器类Timer(from timeit import Timer),生成该类实例对象timer1=Timer(第一个参数为预测试的代码,第二个参数"from __main__ import x(在该模块下独立执行时main,假设x为代表测试代码段的变量名)",第三个参数与操作平台有关(一般缺省)),以对象方法timer1.timeit(number=1000)测试执行代码1000次耗时的平均值。

    10.list内置操作的时间复杂度:

    时间复杂度的解释:与索引相关的两个操作是根据给定的列表起始地址加索引偏移量之间进行一次运算便可访问,所以是O(1);append()与pop()是直接对末尾元素进行操作,一步便可操作完成,O(1);但pop(i)当i=0时要弹出第一个元素,这时后边所有的元素都要前移所以O(n);insert()考虑最坏情况,当i等于0时,这时列表所有元素都要后移,为插入到偏移地址为0的新元素腾空间,为O(n);del 元素则其后每个都要复制前移,故O(n);iteraction(迭代器)需要对整个列表遍历访问O(n);要看列表中是否含有某元素需要遍历每个元素,O(n);get slice[x:x+k]首先根据x偏移量一步找到list[x],之后依次访问并取出k个元素,所以O(k);del slice如果只删除第一个元素,则后续每个元素都要前移为O(n);set slice一步定位到插入切片的位置,但如果考虑最坏情况为在表头部插,则O(n),之后再将k个元素依次插入O(k),总的即为O(n+k);reverse逆序排列需要遍历整个列表所以为O(n);concatenate(连接)操作首先直接定位到队尾,再依次将待连接的k个元素添加到相对尾部所以为O(k);multiply需要将长度为n的列表复制k遍,所以时间复杂度为O(nk)。

    append与extend的区别:append接收单个元素添加到列表尾部,不生成新列表对象;extend接收列表对象添加到原列表尾部。

    dict内置操作的时间复杂度:

    时间复杂度的解释:copy字典要对每个键值对进行操作,所以O(n);get item直接根据键可以访问该键值对一步完成,则为O(1);set item直接放入键一步完成或者最坏替换原有键值对两步完成属于基本操作,所以O(1);del item一步直接删除该键值对O(1);contains判断某个键值对是否属于字典,只需要比较字典中有无该键,一步操作O(1);iteration迭代器需要对整个字典进行遍历,所以时间复杂度应为字典的长度,即键值对的个数为O(n)。

    11.数据结构:为了解决问题,需要将数据保存下来,然后根据数据的存储方式来设计算法实现进行处理,那么数据的存储方式不同就会导致需要不同的算法进行处理。我们希望算法解决问题的效率越快越好,于是我们就需要考虑数据究竟如何保存的问题,这就是数据结构。例如以下两种存储结构:列表和字典都可以存储一个班的学生信息,但是想要在列表中获取一名同学的信息时,就要遍历这个列表,其时间复杂度为O(n),而使用字典存储时,可将学生姓名作为字典的键,学生信息作为值,进而查询时不需要遍历便可快速获取到学生信息,其时间复杂度为O(1)。数据结构指数据对象中数据元素之间的关系。实际上,字典、列表、元组、集合已经是对基本数据类型(整型、浮点型、字符串)的组合,已经相当于python 中的几种数据结构。

    数据结构与算法的联系:算法是为了解决实际问题而设计的,数据结构是算法需要处理的问题载体,简而言之,程序=数据结构+算法

    12.抽象数据类型(ADT相当于python中的API,是一种面向对象的设计思想):把数据类型和数据类型上的运算捆在一起,进行封装。一般再开始的时候只需要写明建立什么类,包含什么函数,类与函数的功能分别是什么暂时不用考虑代码的实现(函数体中可以添加pass占位)。最常见的数据操作包括:插入、删除、修改、查找、排序

    13.(补)作业:利用内置类型性能分析函数测试为一个空列表添加1-1000数字的各种方法的平均耗时。(要求使用列表‘+’,append,insert,列表生成器,range创建法,extend。)

    # -*- coding:utf-8 -*-
    from timeit import Timer
    def test1():
        li1=[]
        for x in range(1000):
            li1=li1+[x]    #每次都生成新表,耗时耗空间
    def test2():
        li2 = []
        for x in range(1000):
            li2.append(x)   # 不生成新表,尾部追加模式
    def test3():
        li3 = []
        for x in range(1000):
            li3.insert(x,x)   # 不生成新表,尾部插入模式
    def test4():
        li4=[x for x in range(1000)]   # 列表生成器
    def test5():
        li5 = list(range(1000))
    def test6():
        li6= []
        for x in range(1000):
            li6.extend([x])   #不生成新表,在尾部添加新表
    def test7():
        li7=list()
        for i in range(1000):
            li7.insert(0,i)   #不生成新列表,在头部插入新元素
    def test8(a):
        for i in range(1000): #从尾部弹出元素
            a.pop()
    def test9(b):
        for i in range(1000): #从头部弹出元素
            b.pop(0)
    
    t1=Timer('test1()',"from __main__ import test1")
    print('+:',t1.timeit(number=1000))
    t2=Timer('test2()',"from __main__ import test2")
    print('append:',t2.timeit(number=1000))
    t3=Timer('test3()',"from __main__ import test3")
    print('insert:',t3.timeit(number=1000))
    t4=Timer('test4()',"from __main__ import test4")
    print('列表生成器:',t4.timeit(number=1000))
    t5=Timer('test5()',"from __main__ import test5")
    print('range:',t5.timeit(number=1000))
    t6=Timer('test6()',"from __main__ import test6")
    print('extend:',t6.timeit(number=1000))
    t7=Timer('test7()','from __main__ import test7')
    print('从头部插入元素需要时间:%f'%t7.timeit(number=1000))
    t8=Timer('test8([x for x in range(10000)])','from __main__ import test8')
    print('从尾部弹出元素所需时间:%f'%(t8.timeit(number=1000)))
    t9=Timer('test9([x for x in range(10000)])','from __main__ import test9')
    print('从头部弹出元素所需时间:%f'%(t8.timeit(number=1000)))

    写以上代码时,要注意:首先,pythonfile的名字中不要含有关键字test和其他标准库或者第三方库的名字(abc也不行也是库文件名),另外若在主程序中执行Timer()第二个参数为from   __main__   import···;另外,要注意li=li+[i]与li+=[i]的时间复杂度是不一致的,第一个是每次加i后生成新表,第二个是进行了计算优化的增强型赋值操作,表示对li列表原对象本身在末尾进行添加[i]的操作,这样相当于li.extend([i])。

    注意:运行这个文件应该:创建项目----创建新的package----创建该.py文件,出错后将缓存的文件夹删去,不要使用关键字为函数命名,也不要在此文件中使用数字,这样基本可以保证正常运行。

     

     

     

     

     

     

     

     

    展开全文
  • 五、缩进程序是有层次关系 比如我们...第一句话就是判断语句 以后会学整意思 如果1=1话 就输出“答对了”明白缩进就行了六、标识符 有时候我需要把一个数字和字符串保存起来 用一个名字指代 这就叫标识...
  • 当D为低电平时Q截止电容CEx通过R9(R10)充电,CEx两端电压逐步升高,当CEx两端电压>Uc时,比较器U3B输出低电平,产生INT0中断(INT0中断设置为下降沿触发),中断服务程序读取定时器值,并计算、显示CEx值。...
  • 最后输出结果为true,我们用是== 测试,输出true,说明两者地址是一样a)3 手动入池即使使用new关键字,第一种方式赋值,也可以使用一个java中手动入池指令,让所创建对象入池,以后依然可以背重复使用,...
  • C/C++中##与#使用

    2015-06-14 12:52:24
    //下面是我另一个博客上的内容,移动到这个账号来,移动过来,以后就用这一个账号...下面这段程序的输出结果是: 1 2 3 4 5 6 7 8 9 10 11 #include #define f(a,b) a##b #define
  • 更进一步,规定每个段的第一个索引对应段的锚点位;那么,A[0]是p的锚点位,又是p_的锚点位;则,A[5]是p_的一个锚点位,而不是p的锚点位;假设初始状态:A[0]存放的数据为5、A[3]为6、A[7]为9、A[12]为8,其他数据均为2;...
  • 131-140

    2019-07-13 10:33:55
    注:以下问题的部分解析并非全部是自己原创,只是为了便于以后复习,直接粘贴总结的答案,主要来源是七...1、 以下程序段的输出结果是( ) int p = 1234; printf("%2d\n",p); A 12 B 34 C 1234 D 提示出错、无结果...
  • 在引导程序段内驻留的引导程序中,可以使用SPM指令,实现对应用程序段的写操作(实现在应用自编程IAP功能,使系统能够自己更新系统程序)。 在响应中断服务和子程序调用过程时,程序计数器PC中的返回地址将被存储于...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    5.18 运行时整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。 5.20运行时“nullpointerassignment...
  • 5.18 运行时整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。  5.20运行时“nullpointerassignment...
  • 之前的程序都是临时(transient):只运行一时间并输出结果,当程序运行结束以后,数据就消失了;再次运行程序,将以全新状态开始; 还有持久(persistent),可以长时间运行(或者一直运行),程序重新启动...
  •  GC是垃圾收集意思(Gabage Collection),内存处理是编程人员容易出现问题地方,忘记或者错误内存回收会导致程序或系统不稳定甚至崩溃,Java提供GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  •  5.18 运行时整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。 5.20运行时...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 170
精华内容 68
关键字:

以后程序段的输出结果是