变量

肯定不一样啊，定义到外面是全局的，里面就是局部的

首先输出0然后进入嵌套内for循环输出0～9最后i的值为10进入下一个循环i的值加一系统发现i<＝10为假所以跳出循环

这个是死循环。由于i=0，一进入循环就是i%2==0 所以到i++，之后i=1从此以后，i%2=1永远成立。所以 一直运行到if(i%2)continue;这里就又回到了while(i<10)。i永远是1，没运行到i++,一直死循环。

for里面第一个分号留空就行了

这就的看你的程序需求了，一般全局变量都是作为标志量或者是函数要返回一些值的时候用的，一般不用，移植性差，循环变量是一般是一个局部变量，比如while（x>5），这里的x就是循环控制变量，很少用到全局变量的

你要 求和 吗？

如果变量定义在循环内部则做不到，循环结束变量就销毁了。不过可以把相应变量定义在循环外部。 样例程序 #include int main(){ for (int i = 0; i != 1; ++i); std::cout

预处理机制：批处理读取命令时是按行读取的（另外例如for命令等，其后用一对圆括号闭合的所有语句也当作一行），在处理之前要完成必要的预处理工作，这其中就包括对该行命令中的变量赋值。在不启用变量延迟，也不对变量动态捕获其扩展变化时，变量在预处理阶段不作改变setlocalenabledelayedexpansion，就是启用变量延迟，我们可以形象的认为是启用了“对变量动态捕获扩展变化”。而!括起来的变量，就是要动态捕获扩展的目标变量，如果不需要，可以继续使用%括变量。示例@echooffSETLOCALENABLEDELAYEDEXPANSIONfor/l%%iin(1110)do(setvar=%%iecho!var!启用延缓环境变量echo%var%未启用延缓环境变量)

给j赋值81

循环变量1 ＋ 1就是取后面的成员，一个数组，你的变量循环就是取后面的成员和前面的成员比较。如果后面的成员小于前面的成员则交换位置。感觉是冒泡排序法。

在C语言中，不能通过循环语句来定义多个变量。因为C语言规定，变量的定义必须放在执行语句的前面，而循环语句就是一条执行语句，所以不能在循环体中定义变量。举例如下：inti;for(i=0;i

循环变量值一般不能改变的，改变容易出错了，导致循环内的其他功能或者计算出错。如果条件不满足随时可以退出循环。

循环的次数，累加计数

用golbal定义

你直接把步长改为3就可以了啊>> for i=1:3:6iendi = 1i = 4两次！或者用while>> i=1;while(i<=6)i=i+3endi = 4i = 7一共两次。

这是九九乘法口诀的代码，当num=1时，最终循环值还是1。

char a[]="abcde";for(i=0;a;i++) //等价于：for(i=0;a!="";i++)

那个是不可能的不过你可以用数组（ARRAY），这样就有了100个变量了

verilog中for不是这么用的你代码可以这么写的if((sw[3:0]<11)&&(sw[3:0]>3)) begin temp_a <= (14 + 3 * sw[3:0]) / 10; temp_b <= (14 + 3 * sw[3:0]) % 10;end

publicclasshello{publicstaticvoidmain(String[]args){inta,sum=0;for(a=1;a<=100;a++){sum=sum+a;}System.out.println(sum);System.out.println(a);}}

for(i;i<num;i++)改为for(;i<num;i++)

procedure test;var i, j: integer;begin j:=0; for(int i = 0 to 10) do begin j:= j + i; end;end; 对于这个函数，I是循环控制变量，J是累加变量。主要功能就是循环从1到10，累加这些值。付给J最后J存放的是累加得值

可以。。。。

可以定义的，没问题，只不过每次循环之后就失效了，也就是每循环一次就会重新定义一个相同名称的变量不过你那段代码有点问题，循环里边的 j 没声明。int i;for(i=0;i<10;i++){ int j=0;}这种定义方式完全没问题，不过会有一点资源浪费，不如直接在外边定义了，然后只在里边改变值如：int i;int j;for(i=0;i<10;i++){ j=0;}

变量循环首 里的第一个参数是，变量起始值，指从这个数值开始按照递增值一步步向目标值循环，而第四个值——循环变量二，则记录 变量循环首 每次循环时 循环变量的值。在第一次循环时，参数一：变量起始值=参数四：循环变量；以后的循环中，循环变量才会递增或递减。从LZ上述代码可以看出，变量循环首 第一次循环比较的是 数组[1] 与 数组[2] 的值，如果 循环变量1 不+1，那么 循环变量2=循环变量1=1，不能实现对比功能，所以 循环变量1 才会+1，以实现循环变量2=2。第二次循环时，循环变量1=2，循环变量2=3，依次类推，实现了对比排序的目的。 变量循环首 命令 操作系统支持：Windows、Linux、Unix 所属类别：流程控制执行本命令将利用变量对循环体内的命令进行循环执行。第一次执行此命令时将使用“变量起始值”参数初始化“循环变量”参数所指定的变量。每次（包括第一次）执行到此命令处都将判断循环变量内的值是否已经超过“变量目标值”参数所指定的值，如已超过，则跳转到对应的“变量循环尾”命令的下一条命令处继续执行，否则顺序执行下一条语句继续进行循环。语法： 无返回值 变量循环首 （变量起始值， 变量目标值， 变量递增值， ［循环变量］）

for 变量赋值java for 变量赋值_Java for循环的几种用法详解jimwalk2014原创关注1点赞·2547人阅读本文非常适合初学Java的程序员，主要是来了解一下Java中的几种for循环用法，分析得十分详细，一起来看看。J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现(当 然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其 它循环常用得多)。对于遍历数组，这个循环一般是采取这样的写法：清单1：遍历数组的传统方式/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int j = 0; j < integers.length; j++) {int i = integers[j];System.out.println(i);}而对于遍历Collection对象，这个循环则通常是采用这样的形式：清单2：遍历Collection对象的传统方式/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历 */for (Iterator itr = stringList.iterator(); itr.hasNext();) {Object str = itr.next();System.out.println(str);}而在Java语言的最新版本――J2SE 1.5中，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。1、 第二种for循环不严格的说，Java的第二种for循环基本是这样的格式：for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体借助这种语法，遍历一个数组的操作就可以采取这样的写法：清单3：遍历数组的简单方式/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}这里所用的for循环，会在编译期间被看成是这样的形式：清单4：遍历数组的简单方式的等价代码/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */}这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。而遍历一个Collection的操作也就可以采用这样的写法：清单5：遍历Collection的简单方式/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection list = java.util.Arrays.asList(strings);/* 开始遍历 */for (Object str : list) {System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}这里所用的for循环，则会在编译期间被看成是这样的形式：清单6：遍历Collection的简单方式的等价代码/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历 */for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {Object str = 变量名乙.next();System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。因为在编译期间，J2SE 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。不用“foreach”和“in”的原因Java采用“for”(而不是意义更明确的“foreach”)来引导这种一般被叫做“for-each循环”的循环，并使用“:”(而不是意义 更明确的“in”)来分割循环变量名称和要被遍历的对象。这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题――在Java语言中， 不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字(例如 java.lang.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”)。的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。不过这种会使语法变复杂的策略，并没有得到广泛的采用。“for-each循环”的悠久历史“for-each循环”并不是一个最近才出现的控制结构。在1979正式发布的Bourne shell(第一个成熟的UNIX命令解释器)里就已经包含了这种控制结构(循环用“for”和“in”来引导，循环体则用“do”和“done”来标识)。2、防止在循环体里修改循环变量在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。Java提供了一种机制，可以在编译期间就把这样的操作封杀。具体的方法，是在循环变量类型前面加上一个“final”修饰符。这样一来，在循环体 里对循环变量进行赋值，就会导致一个编译错误。借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。清单7：禁止重新赋值int[] integers = {1， 2， 3， 4};for (final int i : integers) {i = i / 2; /* 编译时出错 */}注意，这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。清单8：允许修改状态Random[] randoms = new Random[]{new Random(1)， new Random(2)， new Random(3)};for (final Random r : randoms) {r.setSeed(4); /* 将所有Random对象设成使用相同的种子 */System.out.println(r.nextLong()); /* 种子相同，第一个结果也相同 */}3. 类型相容问题为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。这些限制之下，循环变量的类型可以有这样一些选择：循环变量的类型可以和要被遍历的对象中的元素的类型相同。例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。清单9：使用和要被遍历的数组中的元素相同类型的循环变量int[] integers = {1， 2， 3， 4};for (int i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}清单10：使用和要被遍历的Collection中的元素相同类型的循环变量Collection< String> strings = new ArrayList< String>();strings.add("A");strings.add("B");strings.add("C");strings.add("D");for (String str : integers) {System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>(全部元素都是String的Collection)等。清单11：使用要被遍历的对象中的元素的上级类型的循环变量String[] strings = {"A"， "B"， "C"， "D"};Collection< String> list = java.util.Arrays.asList(strings);for (Object str : list) {System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类(Wrapper Classes)之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个 Collection< Byte>，也是可行的。清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量int[] integers = {1， 2， 3， 4};for (Integer i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。可以限定元素类型的Collection截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型――它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型(Generics)”机制之后，这个问题才得到了解决。现在可以用Collection< T>来表示全部元素类型都是T的Collection。

可以定义的，没问题，只不过每次循环之后就失效了，也就是每循环一次就会重新定义一个相同名称的变量不过你那段代码有点问题，循环里边的 j 没声明。 int i;for(i=0;i&lt;10;i++){int j=0;}这种定义方式完全没问题，不过会有一点资源浪费，不如直接在外边定义了，然后只在里边改变值如：int i;int j;for(i=0;i&lt;10;i++){j=0;}

　　如果变量定义在循环内部则做不到，循环结束变量就销毁了。　　不过可以把相应变量定义在循环外部。　　样例程序　　#include <iostream>　　int main()　　{　　for (int i = 0; i != 1; ++i);　　std::cout << i << std::endl; //出错　　return 0;　　#include <iostream>　　int main()　　{　　int i = 0;　　for (; i != 1; ++i);　　std::cout << i << std::endl; //输出1　　return 0;　　}　　

for循环中三个表达式 不一定 是针对循环控制变量的。三个表达式中：第一个是循环开始状态，循环开始时执行此表达式 1次，以后不再执行；第二个是循环条件，符合此条件（即条件为真）时循环，不符合时，结束循环；第三个是循环步长，即每循环一次要执行它1次。例如：int x=1,y=1,i=1;for (x=2;i<5;y=y+2){printf("i=%d x+y=%d ",i++,x+y);}它的循环控制变量是 i, 不是 x 和 y。第二个表达式里有循环控制变量，第一，第三个里没有。例如：int x=1,y=1,i=1;for ( ; ; ){ if (i<3)printf("i=%d x+y=%d ",i++,x+y);else break; }；输出： i=1 x+y=2i=2 x+y=2这里三个表达式都是“空的”， 没有东西。所以答案是 不一定。

for i=1 to 10 a=a+1 next i for 至 next 内的内容为循环体,i 为循环变量

记录循环次数，控制循环的进行（用来判断何时退出循环），在循环体中使用的递增量（如数组下标）。　　希望能帮到您

那你干脆定义一个常量与数据算了#defineN100inta[N];

public class hello{public static void main(String[] args){int a,sum=0;for(a=1;a<=100;a++){sum=sum+a;}System.out.println(sum);System.out.println(a);}}

局部变量的使用范围就在for循环，出了那个循环，变量就失去作用。

这东西没必要解释的吧。。 for i := 5 to 10 do writeln(i); 这个展开就是i:= 5;writeln(i);i:= 6;writeln(i);....i:= 10;writeln(i); pascal里的for循环，循环变量一定是每次增1或减1的。to/downto 左边是初值，右边是终值，to的话就是+1，downto就是-1 用begin..end包裹，那是表示一个语句块，因为按规定for语句后只能有一条执行语句，当有多条语句的时候就必须有begin...end来包裹这些语句。

想

python for 循环不能修改循环变量的原因是，range()象是一个迭代器，它只会输出信息，而不能修改迭代器的内容。python iterator的C结构是一个指针和一个对象列表。修改循环对象的值是C的思维方式，最好不要用在写python代码上。

.版本 2.支持库 spec.子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行.局部变量 变量, 整数型, , "10".局部变量 计次, 整数型.计次循环首 (10, 计次) " 添加变量 置随机数种子 () 变量 [计次] ＝ 取随机数 (0, 100).计次循环尾 ().计次循环首 (取数组成员数 (变量), 计次) .如果真 (变量 [计次] ＞ 10) 调试输出 (变量 [计次]) " 你要是编辑框的话这里的调试输出（）可以改成编辑框1.加入文本（变量 [计次]+#换行符） .如果真结束.计次循环尾 ()返回 (0) " 可以根据您的需要返回任意数值 ‘上面你问的那段就是 变量[1]=取随机数 (0, 100)，变量[2]=取随机数 (0, 100)，变量[3]=取随机数 (0, 100)…………变量[10]=取随机数 (0, 100)

不是的，float和double类型也是可以的。如下例子可以用来验证：#include <stdio.h>int main(){ float f; for(f=1.2;f<10;f++) printf("%f,",f); return 0;}

能不能具体一点儿

jjjjjjjjj

定义全局变量，在循环外调用即可

控制循环的次数

通过Next i语句循环，不用对变量i做加1处理。Dim i As integer,sh as string,ch as string ch="abc" for i =1 to len(ch) sh=mid(ch,i,1) print sh;next i这样应该就可以了

可以定义的，没问题，只不过每次循环之后就失效了，也就是每循环一次就会重新定义一个相同名称的变量不过你那段代码有点问题，循环里边的 j 没声明。int i;for(i=0;i<10;i++){int j=0;}这种定义方式完全没问题，不过会有一点资源浪费，不如直接在外边定义了，然后只在里边改变值如：int i;int j;for(i=0;i<10;i++){j=0;}

相当于需要在内存中 一个区域来判断循环的次数，

这得要看你的程序吧！如for(语句一;语句二;语句三)语句二就是判断是否再次执行循环体的条件哦！最后一次循环的值就是整个循环最后的值吧！

静态 那里√

js循环遍历变量的方式有以下几种： 1.for(let i = 0; i < 5; i++) 2.forEach 3.for of 4.for in 那么我们来看下这几种遍历方式的用法，以及退出循环的方法 1.for 这是最常用的遍历方法，for用来遍历数组，可以使用break 退出循环，使用continue来跳过本次循环。 2.forEach 除了抛出异常以外，没有办法中止或跳出 forEach() 循环。 并且forEach不会改变原来的数组 3.for of for of 可以迭代 可迭代对象 （包括 Array ， Map ， Set ， String ， TypedArray ， arguments 对象等等） 对于for of，可以由break, throw 或return终止, 可以用continue略过此次循环。在这些情况下，迭代器关闭。

不是

通常设置整形，不够用就设置长整型，一般不存在次数准确的问题，主要看你次数够不够用当然了，如果是长期使用的，一般是通过时间或是其他的激发程序运行，确保程序长期使用祝好运，望采纳。

动态开辟空间malloc 或者calloc函数

i-1是个固定的值，i是多少i-1就是多少，不会对i做任何变动；i++是先将i打印，再执行i=i+1。

　　记录循环次数，控制循环的进行（用来判断何时退出循环），在循环体中使用的递增量（如数组下标）。　　希望能帮到您

index ， j k只是因为字母表顺序，一般最多 3层循环，所以只用到 i j k，超过 3层很多情况下是逻辑没有简化

估计是因为在之前做科学研究的时候，很多科学家发现这几个字母不太容易受到别的因素的干扰。

就是用于控制循环的变量。比如说，若变量n的值小于10，就执行循环体代码；否则，退出循环。当然，一般情况下，在循环时n的值需要变化，否则会一直无法退出循环（死循环）。这个变量n就叫循环变量。

关于循环变量你可以去看谭浩强的《C语言程序设计》这本书，好多大学里面的计算机系学生都要学它。里面有好多实例，由浅入深。

写循环程序时需要注意循环变量的初值,循环条件和循环变量的增量,这可以称为是循环的三个要素.

存在寄存器的时候有地址吗？？

sbit。bit 位标量是c51编译器的一种扩充数据类型，所以定义11个特殊功能寄存器可寻址位的位变量关键字用sbit。

组态王中寄存器列表 寄存器格式 寄存器范围 数据类型 变量类型 读写属性 寄存器含义 　　　 Vdd 0～9999 BYTE,SHORT,USHORT,LONG,FLOAT I/O整型、I/O实型 读写 V数据区 Idd 0.0～9999.7 BIT I/O离散 只读 数字量输入区,按位读取 0～9999 BYTE I/O整型 数字量输入区,按字节（8位）读取 Qdd 0.0～9999.7 BIT I/O离散 读写 数字量输出区,按位操作 0～9999 BYTE I/O整型 数字量输出区,按字节（8位）操作 Mdd 0.0～9999.7 BIT I/O离散 读写 中间寄存器区,按位操作 0～9999 BYTE I/O整型 中间寄存器区,按字节（8位）操作 2)、寄存器使用举例： 寄存器名称 读写属性 数据类型 变量类型 寄存器说明 V400 读写 BYTE IO整数 V区地址为400的寄存器（一个字节） V416 读写 LONG IO整数 V区地址为416的寄存器（四个字节416、417、418和419） Q0 读写 BYTE IO整数 对应Q区的Q0.0-Q0.7,一个字节（八位） I0.0 只读 BIT I/O离散< 对应I区的I0.0位

直接寻址方式

void TEST(){ int iEax = 0; int iEbx = 0; int iEcx = 0; int iEdx = 0; _asm { mov eax,1 cpuid mov iEax, eax mov iEbx, ebx mov iEcx, ecx mov iEdx, edx }}

可以的需要博途软件把input变量赋值给寄存器变量。博途是西门子新一代全集成工业自动化的工程技术软件，是直观易用，高效和可靠的工程框架。希望我的回答对你有所帮助。

应该没有限制，只要硬件资源够。

当前值和定时器位

西门子200　PPI 组态王设置1、定义组态王设备组态王定义设备时请选择：PLC西门子S7-200系列PPI 2、设备地址及通讯参数定义设备地址格式为：由于S7-200系列PLC 的型号不同，设备地址的范围不同，所以对于某一型号设备的地址范围， 请见相关硬件手册。组态王的设备地址要与PLC的PORT口设置一致.PLC默认地址为2。 建议的通讯参数：设定值 推荐值 波特率 9600 数据位 8 停止位 1 校验位 偶校验 3、组态王数据词典－IO变量定义1)、组态王中寄存器列表 寄存器格式 寄存器范围 数据类型 变量类型 读写属性 寄存器含义 　　　 Vdd 0～9999 BYTE,SHORT,USHORT,LONG,FLOAT I/O整型、I/O实型 读写 V数据区 Idd 0.0～9999.7 BIT I/O离散 只读 数字量输入区,按位读取 0～9999 BYTE I/O整型 数字量输入区,按字节（8位）读取 Qdd 0.0～9999.7 BIT I/O离散 读写 数字量输出区,按位操作 0～9999 BYTE I/O整型 数字量输出区,按字节（8位）操作 Mdd 0.0～9999.7 BIT I/O离散 读写 中间寄存器区,按位操作 0～9999 BYTE I/O整型 中间寄存器区,按字节（8位）操作 2)、寄存器使用举例： 寄存器名称 读写属性 数据类型 变量类型 寄存器说明 V400 读写 BYTE IO整数 V区地址为400的寄存器（一个字节） V416 读写 LONG IO整数 V区地址为416的寄存器（四个字节416、417、418和419） Q0 读写 BYTE IO整数 对应Q区的Q0.0-Q0.7,一个字节（八位） I0.0 只读 BIT I/O离散< 对应I区的I0.0位

什么是动态变量？是动态分配存储的意思么？还是什么？没有听说过啊。

相同：做为标识，帮助记忆！不同：寄存器的名字代表着这个寄存器的地址，而变量是一个地址中数据。通常我们会改变变量的值，但我们通常不会改变寄存器标识符里的值！

全局变量 内存

$readmemb和$readmemh读取的是文本文件 扩展名无所谓 可以随便写 只要在参数中写明就可以这两个函数可以读取文本文件中的数据 然后赋值给定义的变量例如 文件名是test.xxx内容是10010010100100100101verilog代码是reg [9:0] a [1:0];initial$readmemb("test.xxx", a);执行结果就是a[0] = 10"b1001001010a[1] = 10"b0100100101

汇编还是C？C的话编译器会用堆的方式解决。

你这肯定不行啊。两个寄存器的数据是不能这样相加的，这10个数据位本来就是1个数据，你用8位的变量是装不下的，你这么加，连数据都破坏了。首先你要确定你需要的AD转换精度，10位的AD转换结果出来后，你可以用全部10位来进行下一步计算，这样可以达到最高的精度，也就是转换误差小于1/1024，但同时你必须用2个字节来存储这个变量，因为这就不是一个8位数据；如果你不需要这么高的精度，也可以降低数据精度，用一个字节来表示这个信号量，比如只采用其中的8位（误差小于1/256），但是必须是保留高8位，只能舍弃低位的数据，就像212这个数，你降低精度也只能舍弃个位的2，保留近似值210，不能舍掉百位的2，留下个12。你的问题中没有提到两字节转换结果的数据存储形式。假设A存储8位的结果，B的高两位存储2位的结果，它们谁是高位谁是低位必须弄清，如果B是低位，那么整个10位数据就是A*4+B/64，采用8位精度表示的话可以直接用A；如果A是低位，B是高位，那么10位转换结果是B*4+A，8位精度话就是B+A/4.

不可能 我不相信

选择A，在西门子S7-200系列PLC中，16位寄存器VW100由两个八位寄存器VB100和VB101组成，其中VB100为高八位，VB101为低八位。因此VB100在前，VB101在后，选择A。望采纳。。。。。。

从实现效果来说是一样的，都是四位寄存器型，只不过你使用的时候需要注意对应位匹配就是了比如第一个的最低位是a[0]最高位是a[3]第二个的最低位是a[1]最高位是a[4]仅此而已

当然会不够用的啊~所以要定义存储空间~定义好的存储空间可以放东西~这样就解除了存储器的限制了~为什么我就抢不到沙发~- -闷~

从实现效果来说是一样的，都是四位寄存器型，只不过你使用的时候需要注意对应位匹配就是了比如第一个的最低位是a[0]最高位是a[3]第二个的最低位是a[1]最高位是a[4]仅此而已

西门子200　PPI 组态王设置 1、定义组态王设备 组态王定义设备时请选择：PLC西门子S7-200系列PPI 2、设备地址及通讯参数定义 设备地址格式为：由于S7-200系列PLC 的型号不同，设备地址的范围不同，所以对于某一型号设备的地址范围， 请见相关硬件手册。组态王的设备地址要与PLC的PORT口设置一致.PLC默认地址为2。 建议的通讯参数： 设定值 推荐值 波特率 9600 数据位 8 停止位 1 校验位 偶校验 3、组态王数据词典－IO变量定义 1)、组态王中寄存器列表 寄存器格式 寄存器范围 数据类型 变量类型 读写属性 寄存器含义 　　　 Vdd 0～9999 BYTE,SHORT,USHORT, LONG,FLOAT I/O整型、I/O实型 读写 V数据区 Idd 0.0～9999.7 BIT I/O离散 只读 数字量输入区,按位读取 0～9999 BYTE I/O整型 数字量输入区,按字节（8位）读取 Qdd 0.0～9999.7 BIT I/O离散 读写 数字量输出区,按位操作 0～9999 BYTE I/O整型 数字量输出区,按字节（8位）操作 Mdd 0.0～9999.7 BIT I/O离散 读写 中间寄存器区,按位操作 0～9999 BYTE I/O整型 中间寄存器区,按字节（8位）操作 2)、寄存器使用举例： 寄存器名称 读写属性 数据类型 变量类型 寄存器说明 V400 读写 BYTE IO整数 V区地址为400的寄存器（一个字节） V416 读写 LONG IO整数 V区地址为416的寄存器（四个字节416、417、418和419） Q0 读写 BYTE IO整数 对应Q区的Q0.0-Q0.7,一个字节（八位） I0.0 只读 BIT I/O离散< 对应I区的I0.0位