临时变量

#include <iostream>#include <vector>using namespace std;bool isoperator(char op); // 判断是否为运算符int priority(char op); // 求运算符优先级void postfix(char pre[] , char post[],int &n); // 把中缀表达式转换为后缀表达式double read_number(char str[],int *i); // 将数字字符串转变成相应的数字double postfix_value(char post[]); // 由后缀表达式字符串计算相应的中值表达式的值 template <class ElemType> class MyStack{public: const static int MAXSIZE =100; ElemType data[MAXSIZE]; int top;public: void init(); // 初始化栈 bool empty(); // 判断栈是否为空 ElemType gettop(); // 读取栈顶元素(不出栈) void push(ElemType x); // 进栈 ElemType pop(); // 出栈};template<class T> void MyStack<T>::init(){ this->top = 0;}template<class T> bool MyStack<T>::empty(){ return this->top == 0? true : false;}template<class T> T MyStack<T>::gettop(){ if(empty()) { cout << "栈为空！ "; exit(1); } return this->data[this->top-1];}template<class T> void MyStack<T>::push(T x){ if(this->top == MAXSIZE) { cout << "栈已满！ "; exit(1); } this->data[this->top] =x; this->top ++;}template<class T> T MyStack<T>::pop(){ if(this->empty()) { cout << "栈为空! "; exit(1); } T e =this->data[this->top-1]; this->top --; return e;}int main(){ MyStack<int> stack ; stack.init(); //char pre[] ="22/(5*2+1)#"; char exp[100]; cout << "输入表达式(中缀，以#结束)："; cin >> exp; char post[100] ; //cout <<"中缀表达式为："<< pre << endl; int n =0; // 返回后缀表达式的长度 postfix(exp,post,n); cout <<"后缀表达式为："; for( int i =0 ;i < n ;i++) cout << post[i] ; cout << " 由后缀表达式计算出的数值结果: "; cout << postfix_value(post) << endl; system("pause"); return 0;}bool isoperator(char op){ switch(op) { case "+": case "-": case "*": case "/": return 1; default : return 0; }}int priority(char op){ switch(op) { case "#": return -1; case "(": return 0; case "+": case "-": return 1; case "*": case "/": return 2; default : return -1; }}// 把中缀表达式转换为后缀表达式，返回后缀表达式的长度（包括空格）void postfix(char pre[] ,char post[],int &n){ int i = 0 ,j=0; MyStack<char> stack; stack.init(); // 初始化存储操作符的栈 stack.push("#"); // 首先把结束标志‘#"放入栈底 while(pre[i]!="#") { if((pre[i]>="0" && pre[i] <="9")||pre[i] ==".") // 遇到数字和小数点直接写入后缀表达式 { post[j++] = pre[i]; n++; } else if (pre[i]=="(") // 遇到“（”不用比较直接入栈 stack.push(pre[i]); else if(pre[i] ==")") // 遇到右括号将其对应左括号后的操作符（操作符栈中的）全部写入后缀表达式 { while(stack.gettop()!="(") { post[j++] = stack.pop(); n++; } stack.pop(); // 将“（”出栈，后缀表达式中不含小括号 } else if (isoperator(pre[i])) { post[j++] = " "; // 用空格分开操作数( n++; while(priority(pre[i]) <= priority(stack.gettop())) { // 当前的操作符小于等于栈顶操作符的优先级时，将栈顶操作符写入到后缀表达式，重复此过程 post[j++] = stack.pop(); n++; } stack.push(pre[i]); // 当前操作符优先级大于栈顶操作符的优先级，将该操作符入栈 } i++; } while(stack.top) // 将所有的操作符加入后缀表达式 { post[j++] = stack.pop(); n++; }}double read_number(char str[],int *i){ double x=0.0; int k = 0; while(str[*i] >="0" && str[*i]<="9") // 处理整数部分 { x = x*10+(str[*i]-"0"); (*i)++; } if(str[*i]==".") // 处理小数部分 { (*i)++; while(str[*i] >= "0"&&str[*i] <="9") { x = x * 10 + (str[*i]-"0"); (*i)++; k++; } } while(k!=0) { x /= 10.0; k--; } return x;}double postfix_value(char post[]){ MyStack<double> stack; // 操作数栈 stack.init(); int i=0 ; double x1,x2; while(post[i] !="#") { if(post[i] >="0" && post[i] <="9") stack.push(read_number(post,&i)); else if(post[i] == " ") i++; else if (post[i] =="+") { x2 = stack.pop(); x1 = stack.pop(); stack.push(x1+x2); i++; } else if (post[i] =="-") { x2 = stack.pop(); x1 = stack.pop(); stack.push(x1-x2); i++; } else if (post[i] =="*") { x2 = stack.pop(); x1 = stack.pop(); stack.push(x1*x2); i++; } else if (post[i] =="/") { x2 = stack.pop(); x1 = stack.pop(); stack.push(x1/x2); i++; } } return stack.gettop();}

赋值运算优先级低于任何比较运算符，实际上是函数getin返回值与 eof比较的结果，此处getin返回值只是一个临时变量，在于eof比较后就被丢弃了，

的 不用多说 第二个是调用含有参数的构造函数 即创建的pen2 的m_size赋值为10另外,虚机团上产品团购,超级便宜

这是因为：安全性算法中判断是否安全。不能改变Available数组的值。做检验时，要用到Available数组的值。

u8buf，是指针，指向一个[128]大小的字符串，这样强转之后传入strcpy已经会导致崩溃了 char* u8buf；u8buf malloc()；传出指针需要自行销毁

我好像试过去掉优化，似乎没解决问题，我明天再试一下，确定是否如此

但是如果这个a1和a2本来就很复杂，这样简单加起来就不行了。如果在后面sql语句中多次用到a_sum，难道就只能这样写“a1+a2"吗，这样岂不是很不方便！

。。。。怎么解决。。。知道要返回，那你就不要返回临时的啊。。。在函数外面定义一个不好吗？

源程序如下：#include<stdio.h>int main(){ int x,y,t; printf("请输入两个数:"); scanf("%d %d",&x,&y); printf("原始的两个数为: x=%d,y=%d ",x,y); t=x; x=y; y=t; printf("交换后的两个数为: x=%d,y=%d ",x,y); return 0;}测试并显示如下：

先建一个excel文件，然后使用xlswrite函数读入即可 关于将临时变量改为永久变量，使用global函数，这样变量即保存在MATLAB的工作空间中，不受你原来程序影响，先声明：global X，每次使用时再声明：global X;

临时变量法。每次赋值只要读取一个变量的值到寄存器，然后再从寄存器写回到另一个变量中即可，前后涉及两次内存写入操作;对于异或运算操作，很快就可以算出来。

完全可以，个子程序里只要不重复就可以了。和其他子程序无关，和主程序也无关。

就是赋值一个空指针,不赋值也可以,只是赋值了让人更容易理解这个变量是用来准备存放对象的,也方便调错。

在临时变量没有明确的含义之前请不要使用而且临时变量在进入和退出子程序时的值是不会清0的，在使用前需要你自己给他一个明确的数值

没有看懂你写的问题是什么意思

set /p a=0

有问题。 因为const string& fun(){return "some ";} "some "在存放在静态数据区。你那样子返回之后，输出test的时候，很大可能得到的是一堆乱码。

a是局部变量 返回的P指针指向了局部变量的位置 。局部变量在函数运行完后就被回收了

临时变量时暂时保存在局部数据区中的变量，临时变量使用公用的存储区，临时变量好比公园的一个休息桌椅。来公园玩的人都可以用，当前面的人用完了离开了这个桌椅后，可能在桌椅上留下一些不要的东西，当后面的人想要用这个桌椅的时候，想要把自己的东西摆到这桌子上的是 ，就需要先清理这个桌子上的东西，然后才能够使用。这清理东西，就好比是我们说的临时变量中的先赋值后使用。

可以啊！

你是想赋值吗？sqlserver中动态对象一般采用拼接的形式，最后用exec(@sql)来执行不过你的需求，貌似用insert into tb1() select * from tb2就可以解决吧

在FC中，对于临时变量的使用遵循 先赋值 ，后使用的原则，因为系统对于临时变量分配的存储空间为L区域，而L区域属于全程序共用，因此，Temp1所对应的L区域的值在不断的变化。

把临时变量的值赋给指针所指的变量

》临时表：物理上存在的，使用时与正式表无差别；只是在会话结束时，DBy引擎会将它自动删除；》临时变量：形式上是个变量，而不是表；同样是在会话中有效；会话结束，就消失；》WITH ... AS是公共表达式（CTE）的语法表示，它只是逻辑概念，没有物理对象。一个类似情况就是View（相对于Table），没有物理对象。但View至少还有定义存贮在DB系统表中，而CTE只是一种语法表示（仅在执行时才会被解析、翻译）。

SQL数据库中数据处理时，有时候需要建立临时表，将查询后的结果集放到临时表中，然后在针对这个数据进行操作。创建“临时表”（逻辑上的临时表，可能不一定是数据库的）的方法有一下几种：1.with tempTableName as方法（05之后出现）：with temptable as 其实并没有建立临时表，只是子查询部分（subquery factoring），定义一个SQL片断，该SQL片断会被整个SQL语句所用到。有的时候，是为了让SQL语句的可读性更高些，也有可能是在UNION ALL的不同部分，作为提供数据的部分。特别对于UNION ALL比较有用。因为UNION ALL的每个部分可能相同，但是如果每个部分都去执行一遍的话，则成本太高，所以可以使用WITH AS短语，则只要执行一遍即可。http://www.cnblogs.com/zhaowei303/articles/4204805.html

是。临时变量一定是局部变量。临时变量指的是未在程序开头部分声明的，待使用它时才声明类型的变量。常见的如函数中定义的变量，循环语句、条件语句中声明定义的变量。

【答案】：BB。【解析】按逻辑位运算特点：①用按位与运算将特定位清为0或保留特定位；②用按位或运算将特定的位置为l；③用按位异或运算将某个变量的特定位翻转或交换两个变量的值。

Function DXJ(x1, y1, x2, y2, x3, y3) As Double dim a as Double,b as Double,c as Doublea = (y2 - y2) / (x2 - x1)b = -1c = (y1 - a * x1)DXJ = Abs(a * x3 + b * y3 + c) / ((a ^ 2 + b ^ 2) ^ 0.5)End Function

其实无论以值传递还是以指针传递都是传递的一份拷贝。为什么说以值传递方式传递给函数参数会产生临时变量：因为你值传递给形参的时候只是传的值的一份拷贝，这个拷贝存放在形参中，所以说形参是参数的一个副本，等这个函数结束调用的时候。这个形参所占有的内存会被系统收回

临时变量使用要首先赋值，要不其初始值是随机的，你可以监控一个临时变量看看，他的初始值是不确定的，临时变量不是全局变量，同一个名称在不同的FC里并没有任何关联弱弱的问一句，楼主还在（有生命）吗？

堆栈上的内容只有等其他数据入栈以后才可能被覆盖，在此之前只不过修改了栈指针，不要被写书的人给骗了。

order by + top 1

临时副本，这牵扯到生存期的问题，当程序运行结束时，a就会随之销毁

IN OUT IN/OUT 这些是FB FC里的形式参数，是在FB FC里定义的。

用梯形图方式的话在当前窗口上方，可以建本地程序块的临时变量。同一级POU的临时变量使用局部数据堆栈中的同一块物理存储区，类似于公用的布告栏，谁都可以往上面贴布告，后贴的布告将原来的布告覆盖掉。每次调用POU之后，不再保存它的临时变量的值。每次调用FC和FB时，首先应初始化它的临时变量写入数值，然后再使用它，简称为先赋值后使用。博途怎样快速添加变量首先打开一个项目，你会在左侧的PLC的下拉菜单里面找到监控与强制表。在监控与强制表表中新建一个监控表用来监控当前PLC的数据。新建行并在地址列中添加我们要监控变量的实际地址DI或AI。单击工具栏中的眼镜监控按钮，监控变量的实际值就会显示出来。对于具体某个点的地址我们可以用如下方法进行查找。在设备视图中单击需要查看地址的PLC模块，在属性栏中查看IO变量下面可以看到具体每个点的实际地址。我们双击打开强制表，在强制表内输入需要强制的变量地址DO或AO。设定强制值并勾选F列中的选择框。单击工具栏中的启动或替换可见变量的强制，变量就强制到我们希望的数值了。在强制或监控表中还可以如EXCEL一样进行任意拖拽十分方便。

打开编程软件，点SBR_0进入子程序编程界面。先写好熟悉的自保停程序，进行转化成子程序。打开子程序接口变量表即可。子程序（subprogram）是对与子计算任务相应的处理对象和处理规则的描述。

可以，你用for循环，例如for i in 0..10 loop,这里的i就是临时变量

【答案】：B按逻辑位运算特点：①用按位与运算将特定位清为0或保留特定位；②用按位或运算将特定的位置为1；③用按位异或运算将某个变量的特定位翻转或交换两个变量的值。

能。临时变量与局部变量没有区别，因为，临时变量与局部变量没有区别的，所以说，临时变量也就是说，临时的变量，而局部变量也就是说，局部的变量，无论怎么说，临时变量和局部变量也就是说，临时的变量和局部的变量，因此，没有区别的没有区别的。

成员变量是属于类的一个属性，按照面向对象的概念可以比喻成我们人的某一部位，类就是这个人，这个成员变量就是某一部位。局部变量只是在方法里临时提供一个存储的位置，当方法结束时，该变量也会被垃圾回收器销毁，而成员变量只有这个对象被销毁时才被销毁。你可以把内存分成两部位，一块叫堆区，一块叫栈区，程序中引用类型（对象）都存储在堆上，而基本数据类型和引用变量都存储在栈上，比如：A a = new A();new A()返回一个对象的地址给a，new A()实际的值存储在堆上，而a得到的地址存储在栈上，基本数据类型肯定存储在栈上，这是因为他们的长度是固定的，而对象的长度则不是固定的

表示A &R1 = fun1();不能通过编译.

你不定义变量，编译器自己怎么产生临时变量，那不是失去控制了？

你要把swap改成swap_int或者别的名字iostream里面可能已经有一个swap的template

当函数形参是一个const引用的时候，是否产生临时对象？ double a = 1.34 ; const int &b = a ; const int &c = 1024 ; 在上面的const引用中都产生了临时变量，然后引用变量指向该临时变量。 在函数传递中，比如： class X {}; X f() void g1(X&) {} void g2(const X&) {} int main() { g1(f()) ; g2(f()); return 0; } 因为在f()函数返回的是一个临时变量，因此f()函数结束的时候这个临时变量的生命期也应该 结束了。因此g1的调用是非法的，至于g2则因为是const引用，所以产生了另一个临时变量。 g2的调用是可以的。↓

int a=0; ++(a++); 或者++a++； 程序出错；因为a++返回的是一个临时变量，而 临时变量都是const ，表示的是一个右值，对常量++显然错误。左值和右值的区分： 左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值是指表达式结束时就不再存在的临时对象。一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。

构造函数a （a对象的创建）执行复制构造函数 （按值传递，a传给one,调用拷贝构造函数创建one）执行复制构造函数 （return one，函数按值传递，one传给一个临时变量，调用拷贝构造）析构 （析构 one对象）析构 （析构临时变量）析构 （析构 a对象）

临时变量本质是一个暂元，仅在执行程序时存入内存中，当程序执行完毕变自动删除。 在实际应用中，当我们要产生一些不用以直接分析的变量，我们均可使用临时变量进行替换。

LB12。OB1的临时变量的地址区是OB1单独使用的，地址是LB12。OB的临时变量可以是基本数据类型、复杂数据类型或数据类型ANY，OB块包含OB的启动信息的20B的临时局部变量TEMP，这些信息在OB启动时由操作系统提供。

可以 只有声明为常量的变量才不能做佐值 再看看书吧 这一章的知识挺重要的

临时变量并不是功能执行结束就清零的。局个例子：OB1中调用FC1,FC1中编辑:AM0.0S#temp0A#temp0=M0.1除此之外不含有其他程序。首先置位M0.0那么M0.1也被置位，然后M0.0复位但M0.1仍然为1。这表明temp0所占用的L区并没有被清零。做另外一个试验：在OB1中增加调用FC2,在FC2中编辑：L0T#temp0T#temp0_1T#temp0_2T#temp0_3T#temp0_4T#temp0_5T#temp0_6T#temp0_7T#temp0_8T#temp0_9T#temp0_10T#temp0_11T#temp0_12T#temp0_13T#temp0_14T#temp0_15T#temp0_16T#temp0_17T#temp0_18T#temp0_19temp都为DWORD类型。重复上面的测试过程先置位M0.0那么M0.1也被置位，然后M0.0复位M0.1变为0。temp0所占用的L区被清零。根据上面的试验我认为：temp变量在使用后它所对应的物理地址的数值并不变化，除非在另外的块中的临时变量分配了与之前临时变量相同的物理地址可能会改变该物理地址的数值。这也就是临时变量要先赋值后使用的原因。

楼主所说的临时变量指的应该是FC或FB中的TEMP类型的变量，这些变量只能在当前块内使用，而且必须先赋值给线圈/变量，然后才能使用触点/变量。因为临时变量的值仅在被调用FC/FB块程序运行的时间内有效，FC/FB每次被调用结束时，该块所使用的临时变量都将被清零。换句话说，临时变量是没有固定的存储地址的，只有在FC/FB块被调用的时候，CPU才分配临时存储空间给当前运行的程序块，临时变量使用的就是这些临时的存储空间，在程序块运行结束后，这些临时存储空间就被CPU收回了。而楼主说"不能在两个FC中同时使用L0.0"是错误的，FC/FB块使用的临时变量可以相同，因为他们的生命周期只有一个程序块的运行时间。建议楼主检查一下是不是有程序写错了。

正确的叫法应该是过程级变量，过程是指Sub或者Function过程，通常使用DIM进行声明。Dim声明的变量，只在该过程执行时存在，过程结束，变量的值也就销毁了。

暂时存储数据的变量。这些临时的数据存储在CPU工作存储区的局部数据堆栈（L堆栈）中。西门子1500临时变量定义暂时存储数据的变量。西门子博途S1500是西门子公司的最新PLC，也是西门子未来发展的主要方向，因此学好它对于日后的工控有重要的意义。

1 在VC++ 2005下执行会报错。因为输出x前没有赋值。2 输出1234是巧合。#include<stdio.h>void main(){ int i; for(i=1;i<=2;i++) { int x; if(i==1)x=1234; else if(i==2){int a[1000];printf("%d",x);} //这儿分配一些单元，就不会巧合了。 }}

这指的是在未在程序开头部分声明的，待使用它时才声明类型的变量。常见的如函数中定义的变量，循环语句、条件语句中声明定义的变量。这些变量可与主程序中的变量同名，在其作用区段，主程序中的同名变量一般无法调用。并且这种变量有效存在时间是从变量声明开始到相应程序段（循环结构或函数体）结束。

没有名字的对象就是临时对象，它存在于完整的表达式的生存其间。也就是说，当表达式计算结束后就会被释放。一个例外是，当临时对象被引用时，它的生存期将延长到与这个引用的生存期一样长。 局部对象就是可见区域在一个函数范围的对象。 局部对象有两种，静态局部对象的生存期起于所在函数第一次被调用，结束于main()函数退出之后。自动局部对象生存期起于所在函数每一次被调用，结束于函数返回。 A fun() { return A();//创建一个A的临时对象并返回。这个临时对象将被拷贝给调用者的临时对象，然 后释放（在进行了RVO时不创建临时对象，而是直接构造调用者的临时对象）。 } A a; a = fun();//调用fun，产生一个临时对象；用这个临时对象为参数调用a的拷贝赋值操作符，然释放临时对象。 const A b& = fun();//调用fun，产生一个临时对象，这个对象并不会马上被释放，而是会在离开b的作用域后释放，因为它被b引用了。

declare datebak char好像是这么写的

https://en.cppreference.com/w/cpp/language/reference_initialization#Lifetime_of_a_temporary 当临时对象被绑定到引用的时候，引用会延长临时对象的生命周期，临时对象的生命周期将会跟引用的生命周期一样。但也有例外的情况： 不会扩展对return语句中函数的返回值的临时绑定：它会在返回表达式的末尾立即销毁。 这样的函数总是返回一个悬空引用。 譬如 这种情况a将会是一个空悬指针，俗称野指针。 绑定到构造函数初始构造列表中的引用成员的临时绑定仅在构造函数退出之前持续存在，而不是在对象生命周期存在，构造函数退出后就不存在了。(c++14之后不适用) 构造函数的初始化构造列表： 如果函数参数为引用，当临时对象绑定到该参数上时，其生命期一直持续到包含该函数调用的表达式的结束，如果该函数又返回了引用，则在表达式结束之后，该引用成为空悬引用： 临时对象绑定到new表达式中使用的初始化列表引用，则其生命期直到包含该new-expression的完整表达式结束，而不是初始化对象。 在表达式结束之后，则其引用成员将成为悬空引用。 a temporary bound to a reference in a reference element of an aggregate initialized using direct-initialization syntax (parentheses) as opposed to list-initialization syntax (braces) exists until the end of the full expression containing the initializer. 临时对象绑定到使用直接初始化语法（括号）聚合初始化的引用元素中的引用，而不是列表初始化语法（大括号），生命期只能延续到包含初始化程序的完整表达式结束之前。 通常，临时的生命周期不能通过“传递”来进一步扩展：从临时绑定的引用初始化的第二个引用不会影响其生命周期，譬如：A是临时对象的引用，B是A的引用，B的生命周期并不会影响临时对象的生命周期。 仅在函数形参声明，函数返回类型声明，类成员声明，以及带 extern 说明符时，引用可以不与初始化器一同出现。（也就是说在其他情况，引用必须被初始化）

方法内的变量，就是只能在方法内使用！

函数返回后临时变量占用的内存已被释放，如果继续访问临时变量，则行为未定义，所以不一样！

西门子临时变量的意思就是：进入子程序后，系统为临时变量分配存储地址，子程序调用结束后，系统不会清空这些分配的地址而是直接给下一个子程序使用。通俗的讲，就像客房一样，系统不会打扫干净给下一个租客，所以下一个租客直接使用的话会有问题。因此，需要程序员遵守这样一样原则：临时变量：先赋值后使用。