程序员打电话死循环

‘壹’ 我是一个程序员，但每天的工作都是打电话联系合作方，代码都没怎么写过。。。我还算是程序员吗

为什么向别的公司要技术材料？

如果感觉自己的工作内容和自己的本职工作出入太大，自己刚好又不喜欢现在的工作，但是现在的公司待遇还不错，建议：

1. 和自己的直接上司沟通，将自己的想法告诉他，希望以后的工作内容是自己的本职工作；

2. 如果有足够的能力，如果够年轻，跳槽未尝不可，也可以接触更多的东西。

‘贰’ 程序中有两个死循环,为什么还会继续执行

计算机只会依据程序员设计的程序进行

‘叁’ 大牛们，为什么这个程序是个死循环而不是报错误呢

.
死循环死递归死锁CPU消耗基本相同产原
、死循环
例VB语言程序列语句：
Do While i=1
print "*"
Loop
死循环运行休止打印*号
存种算任何程序及相应输入数据都判断否现死循环任何编译系统都做死循环检查
设计程序若遇死循环我通按Ctrl+Pause/Break结束死循环
编程死循环并需要避免问题相反实际应用经需要用死循环例我使用Windows操作系统窗口程序窗口都通叫消息循环死循环实现单片机、嵌入式编程经要用死循环各类编程语言死循环都种实现C语言例别使用while.for,goto实现
二、死锁
两或两进程执行程由于竞争资源或者由于彼通信造种阻塞现象若外力作用都推进称系统处于死锁状态或系统产死锁些永远互相等待进程称死锁进程
计算机系统系统资源配策略更见能程序员写程序错误等则导致进程竞争资源产死锁现象
两或任务每任务锁定其任务试图锁定资源造些任务永久阻塞现死锁例：事务A 获取行 1 共享锁事务 B 获取行 2 共享锁
排锁等待事务 B 完并释放其行 2 持共享锁前阻塞
排锁等待事务 A 完并释放其行 1 持共享锁前阻塞
事务 B 完事务 A 才能完事务 B 由事务 A 阻塞该条件称循环依赖关系：事务 A 依赖于事务 B事务 B 通事务 A 依赖关系关闭循环
三、死机及其策
论死循环死锁都造电脑死机现象
?电脑系统工作候现鼠标停滞、键盘能输入命令等情况系统已经能接收任何命令种情况称死机死机能种原造比同运行应用程序程序使用错误电脑某硬件损坏（比硬盘或者内存）等都能引起死机解决用：
同按键盘控制键加换档键加删除键显示列表单击【启任务管理器】命令弹【任务管理器】框单击现问题程序再单击【结束任务】按钮所选程序立即结束运行数情况都通述关闭已经失响应程序并且继续Windows10操作
键盘已经能输入任何命令按机箱复位键几秒钟电脑重新启
机箱没复位键直接按住机箱电源关几秒钟关闭电脑电源稍再按机箱电源关重新启电脑即

‘肆’ c语言陷入死循环，应该怎么改呢拜托拜托，求大佬解答

1、DateCheck（）函数是否处理有问题
2、输入要英文模式下数字，
3、单步骤调试一下

‘伍’ 死循环是什么意思

“死循环”的意思：单一程序在某一环节由于未满足脱离循环的条件而出现的持续进行循环操作的现象。它能让程序运行陷入停滞，严重时会拖慢电‌‌‌‌‌‌‌脑速度，是让程序员头疼的故障情况之一。

读音：sǐ xún huán

词性：通常在句中用作名词，作为主语或宾语。

例句：如果他们不一遍又一遍的提高自己编写保龄球游戏代码的技巧，他们很可能会让数据库陷入死循环。

近义词介绍：循环往复

读音：xún huán wǎng fù

表达意思：意思是转了一圈又一圈，一次又一次地循环。

词性：通常在句中用作动词，修饰主语或宾语。

例句：时间是生命的通行证，来也匆匆，去也匆匆，每一个季节的更迭，生命都在不断地消失，新的生命又在不断地降临。循环往复，生命的河流生生不息，获得了永恒。

‘陆’ 我运行的C语言程序挂起了，应该怎么办

当你运行一个程序时会有多种原因使它挂起，这些原因可以分为以下4种基本类型：
(1)程序中有死循环；
(2)程序运行的时间比所期望的长；
(3)程序在等待某些输入信息，并且直到输入正确后才会继续运行；
(4)程序设计的目的就是为了延迟一段时间，或者暂停执行。
在讨论了因未知原因而挂起的程序的调试技巧后，将逐个分析上述的每种情况。
调试那些因未知原因而挂起的程序是非常困难的。你可能花费了很长的时间编写一个程序，并努力确保每条代码都准确无误，你也可能只是在一个原来运行良好的程序上作了一个很小的修改，然而，当你运行程序时屏幕上却什么也没有显示。如果你能得到一个错误的结果，或者部分结果，你也许知道应该作些什么修改，而一个空白的屏幕实在令人沮丧，你根本不知道错在哪里。
在开始调试这样一个程序时，你应该先检查一下程序结构，然后再按执行顺序依次查看程序的各个部分，看看它们是否能正确运行。例如，如果主程序只包含3个函数调用——A()、B()和C()，那么在调试时，你可以先检查函数A()是否把控制权返回给了主程序。为此，你可以在调用函数A()的语句后面加上exit()命令，也可以用注释符把对函数B()和C()的调用括起来，然后重新编译并运行这个程序。
注意：通过调试程序(debugger)也可以做到这一点，然而上述方法是一种很传统的调试方法。调试程序是一个程序，它的作用是让程序员能够观察程序的运行情况、程序的当前运行行号、变量的值，等等。
此时你将看到函数A()是否将控制权返回给了主程序——如果该程序运行并退出，你可以判断是程序的其它部分使程序挂起。你可以用这种方法测试程序的每一部分，直到发现使程序挂起的那一部分，然后集中精力修改相应的函数。
有时，情况会更复杂一些。例如，使程序挂起的函数本身是完全正常的，问题可能出在该函数从别的地方得到了一些错误的数据。这时，你就要检查该函数所接受的所有的值，并找出是哪些值导致了错误操作。
技巧：监视函数是调试程序的出色功能之一。
分析下面这个简单的例子将帮助你掌握这种技巧的使用方法：
#include <stdio. h>
#include <stdlib. h>
/*
* Declare the functions that the main function is using
*/
int A(), B(int), C(int, int);
/*
* The main program
*/
int A(), B(), C(); /*These are functions in some other
mole * /
int main()
{
int v1, v2, v3;
v1 = A();
v2 = B(v1);
v3 = C(v1, v2);
printf ("The Result is %d. \n" , v3);
return(0) ;
}
你可以在调用函数A()的语句后输出变量v1的值，以确认它是否在函数B()所能接受的值的范围之内，因为即使是函数B()使程序挂起，它本身并不一定就有错，而可能是因为函数A()给了函数B()一个并非它所期望的值。
现在，已经分析了调试“挂起”的程序的基本方法，下面来看看一些使程序挂起的常见错误。
一、死循环
当你的程序出现了死循环时，机器将无数次地执行同一段代码，这种操作当然是程序员所不希望的。出现死循环的原因是程序员使程序进行循环的判断条件永远为真，或者使程序退出循环的判断条件永远为假。下面是一个死循环的例子：
/* initialize a double dimension array */
for (a = 0 ; a < 10; ++a )
{
for(b = 0; b<10; ++a)
{
array[a][b]==0;
}
}
这里的问题是程序员犯了一个错误(事实上可能是键入字母的错误)，第二个循环本应在变量b增加到10后结束，但是却从未让变量b的值增加!第二个for循环的第三部分增加变量a的值，而程序员的本意是要增加变量b的值。因为b的值将总是小于10，所以第二个for循环会一直运行下去。
怎样才能发现这个错误呢?除非你重新阅读该程序并注意到变量b的值没有增加，否则你不可能发现这个错误。当你试图调试该程序时，你可以在第二个for循环的循环体中加入这样一条语句：
printf(" %d %d %d\n" , a , b , array[a][b]) ;
这条语句的正确输出应该是：
0 0 0
0 1 0
(and eventually reaching)
9 9 0
但你实际上看到的输出却是：
0 0 0
1 0 0
2 0 0
...
你所得到是一个数字序列，它的第一项不断增加，但它本身永远不会结束。用这种方法输出变量不仅可以找出错误，而且还能知道数组是否由所期望的值组成。这个错误用其它方法似乎很难发现!这种输出变量内容的技巧以后还会用到。
产生死循环的其它原因还有一些其它的原因也会导致死循环。请看下述程序段：
int main()
{
int a = 7;
while ( a < 10)
{
+ +a;
a /= 2;
}
return (0);
}
尽管每次循环中变量a的值都要增加，但与此同时它又被减小了一半。变量a的初始值为7，它先增加到8，然后减半到4。因此，变量a永远也不会增加到10，循环也永远不会结束。
二、运行时间比期望的时间长
在有些情况下，你会发现程序并没有被完全“锁死”，只不过它的运行时间比你所期望的时间长，这种情况是令人讨厌的。如果你所使用的计算机运算速度很快，能在极短的时间内完成很复杂的运算，那么这种情况就更令人讨厌了。下面举几个这样的例子：
/*
* A subroutine to calculate Fibonacci numbers
*/
int fib ( int i)
{
if (i <3)
return 1;
else
return fib( i - 1)+fib( i - 2);
}
一个菲波那契(Fibonacci)数是这样生成的：任意一个菲波那契数都是在它之前的两个菲波那契数之和；第一个和第二个菲波那契数是例外，它们都被定义为1。菲波那契数在数学中很有意思，而且在实际中也有许多应用。
注意：在向日葵的种子中可以找到菲波那契数的例子——向日葵有两组螺旋形排列的种子，一组含21颗种子，另一组含34颗种子，这两个数恰好都是菲波那契数。
从表面上看，上述程序段是定义菲波那契数的一种很简单的方法。这段程序简洁短小，看上去执行时间不会太长。但事实上，哪怕是用计算机计算出较小的菲波那契数，例如第100个，都会花去很长的时间，下文中将分析其中的原因。
如果你要计算第40个菲波那契数的值，就要把第39个和第38个菲波那契数的值相加，因此需要先计算出这两个数，而为此又要分别计算出另外两组更小的菲波那契数的和。不难看出，第一步是2个子问题，第二步是4个子问题，第三步是8个子问题，如此继续下去，结果是子问题的数目以步数为指数不断增长。例如，在计算第40个菲波那契数的过程中，函数fib()将被调用2亿多次!即便在一台速度相当快的计算机上，这一过程也要持续好几分钟。
数字的排序所花的时间有时也会超出你的预料：
/*
* Routine to sort an array of integers.
* Takes two parameters:
* ar---The array of numbers to be sorted, and
* size---the size of the array.
*/
void sort( int ar[], int size )
{
int i,j;
for( i = 0; i<size - 1; ++ i)
{
for( j = 0; j< size - 1; ++j )
{
if (ar[j]>ar[j + 1])
{
int temp;
temp = ar[j];
ar[j] = ar[j + 1];
ar[j + 1] = temp;
}
}
}
}
如果你用几个较短的数列去检验上述程序段，你会感到十分满意，因为这段程序能很快地将较短的数列排好序。如果你用一个很长的数列来检验这段程序，那么程序看上去就停滞了，因为程序需要执行很长时间。为什么会这样呢?
为了回答上述问题，先来看看嵌套的for循环。这里有两重for循环，其中一个循环嵌套在另一个循环中。这两个循环的循环变量都是从O到size-1，也就是说，处于两重循环之间的程序段将被执行size*size次，即size的平方次。对含10个数据项的数列进行排序时，这段程序还是令人满意的，因为10的平方只有100。但是，当你对含5000个数据项的数列进行排序时，循环中的那段程序将被执行2500万次；当你对含100万个数据项的数列进行排序时，循环中的那段程序将被执行1万亿次。
在上述这些情况下，你应该比较准确地估计程序的工作量。这种估计属于算法分析的范畴，掌握它对每个程序员来说都是很重要的。
三、等待正确的输入
有时程序停止运行是因为它在等待正确的输入信息。最简单的情况就是程序在等待用户输入信息，而程序却没有输出相应的提示信息，因而用户不知道要输入信息，程序看上去就好象锁住了。更令人讨厌的是由输出缓冲造成的这种结果，这个问题将在17．1中深入讨论。
请看下述程序段：
/*
*This program reads all the numbers from a file．
* sums them, and prints them.
*/
# include <stdio. h>
main()
{
FILE *in = fopen("numbers.dat", "r");
int total = 0, n;
while( fscanf( in, " %d" , &n )! =EOF)
{
total + = n;
}
printf( "The total is %d\n" , total);
fclose ( in ) ;
}
如果文件NUMBERS．DAT中只包含整数，这段程序会正常运行。但是，如果该文件中包含有效整数以外的数据，那么这段程序的运行结果将是令人惊奇的。当该程序遇到一个不恰当的值时，它会发现这不是一个整数值，所以它不会读入这个值，而是返回一个错误代码。但此时程序并未读到文件尾部，因此与EOF比较的值为假。这样，循环将继续进行，而n将取某个未定义的值，程序会试图再次读文件，而这一次又遇到了刚才那个错误数据。请记住，因为数据不正确，所以程序并不读入该数据。这样，程序就会无休止地执行下去，并一直试图读入那个错误的数据。解决这个问题的办法是让while循环去测试读入的数据是否正确。
还有许多其它原因会使程序挂起，但总的来说，它们都属于上述三种类型中的某一种。

‘柒’ C++程序陷入死循环，如何避免

防错处理是编程非常重要的工作.
因此,你在程序设计的时候,就需要考虑所有可能的输入情况.
把不期望的输入过滤出来不做处理,或做错误处理.只对期望的输入做处理.

如果你在程序设计之初没有考虑对输入做检查的话,程序就会非你所愿的执行,这就是危害.没有什么比程序没有如程序员想象的那样去执行危害更大了.

以你的这个例子来说的话,你获取到输入后,就要判断输入的是什么,如果用户输入的是数字,那你就正常处理,如果用户输入的是其他你不希望的值,那你可以打印一个提示,说,请输入整数.然后程序返回.等等.

自己多考虑考虑.

‘捌’ 测试当中什么是死循环

死循环是一种现象
原理: 在while循环中,没有修改循环变量的值, 导致while后面条件判断一直成立,
一直执行缩进部分代码, 无法退出循环的一种现象
注意: 要避免死循环, 修改循环变量,便于下一次循环,最终退出循环
(拓展:死循环也有妙用,比如Windows桌面一直运行, 就是死循环实现的,但死循环也要有退出口,使用break退出死循环)
想要相关实现的操作和源码，参考黑马程序员的相关教程，官网都有配套资料，资料当中就含有课件+笔记+源码了。总之非常适合小白学习，想要学习的可以去看看。

‘玖’ 死循环的举例

以下是一些死循环的例子。
C++的例子
#include<iostream.h>
int main()
{
for(int i=0;;i++)
{
cout<<char(i);
}
return 0;
}
C语言的死循环：
#include <stdio.h>
main()
{
int a = 0;
while (a < 10)
{
printf(%d , a);
if (a = 5) {
printf(a equals 5! );
}
a++;
}
return 0;
}
上述程序会一直显示Infinite Loop字符串。
BASIC语言的死循环：
10 PRINTInfinite Loop
20 GOTO10'跳到行号=10的位置
X86汇编语言的例子：
loop:
; Code to loop here
jmploop
Python的例子：
whileTrue:
print(Infinite Loop) 以下是一个Visual Basic死循环的例子：
dimxasintegerdountilx > 5'根本不会有x>5的情形x = 1 x = x + 1loop
每一次运行循环时x会先设置为1，然后变为2，因为数值未大于5，所以永远不会退出。若将x = 1由循环内部移到循环之前即可以改善此一情形。
有些程序员可能因为不熟悉特定编程语言的语法而造成死循环，例如以下是一段C语言的程序：
#include <stdio.h>
main()
{
int a=0;
while(a<10)
{
printf(%d ,a);
if(a=5){//a设定为5，进入无穷回圈printf(a equals 5! );}
a++;
}
return0;
}
其预期输出是数字0至9，其中5和6中间会显示a equals 5!，但程序员在编写程序时将设置用的=运算符及判断相同的==运算符弄混了，因此程序会在每次运行循环时都会将a设置为5，因此变量a永远无法到达10，此循环就变成了死循环。 有时不适当的循环退出条件也可能会造成无预期的死循环，例如以下C语言的例子：
float x=0.1;
while(x!=1.1)
{
//可能会因为浮点运算的误差而出现问题
printf(x = %f ,x);
x=x+0.1;
}
在有些操作系统中，上述程序会运行10次循环然后退出，但有些系统中，上述程序却可能会一直运行，无法退出，问题主要在循环的退出条件(x != 1.1)要在二个浮点数相等时才退出，结果会依系统处理浮点数的方式而定，只要系统运行10次循环后的结果和1.1差一点点，上述程序就会变成死循环。
若将退出条件改为(x < 1.1)就没有这个问题，程序可能会多运行一次循环，但不会变成死循环。另一种解决方式则是用一个整数变量作为循环变量，再依此变量判断是否要退出循环。
在数值分析程序中也可能会出现无预期的死循环，例如程序需一直迭代到误差小于某特定值为止，但若因为运算中的舍去误差，使得误差一直无法小于该特定值，就会产生死循环。 奥尔德森循环（Alderson loop）是指一个循环有设置退出条件，但因为程序的写法（多半是编程错误），造成永远无法满足退出条件，在针对用户界面程序调试时最容易出现这类的问题。
以下C的伪代码中有一个奥尔德森循环，程序是要计算用户输入一串数字的和，用户输入0时退出循环，但程序中用了不正确的运算符：
sum=0;while(true){printf(Input a number to add to the sum or 0 to quit);i=getUserInput();if(i*0){// 若i乘0为真，则使sum加上i的值sum+=i;// 但这不可能发生，因为不论i为何值（i * 0）都是0。如果条件中用的是!=而非*，代码就能正常运行}if(sum>100){break;// 终止循环。结束条件存在，但从来没有达到过，因为sum永远不会增加}}
“奥尔德森循环”是来自一个Microsoft Access的程序员，他编写的程序产生一个有模式的对话框，用户需要回应，程序才能继续运作，但对话框没有OK键或取消键，因此只要此对话窗出现，Access程序就无法继续运作。 无穷递归是一种由递归造成的死循环。例如以下计算阶乘的C语言程序
unsigned int fac(unsigned int a){
//n!=n*(n-1)!
return(fac(a-1)*a);
}
一般递归的程序会有一特定条件，此条件成立时直接计算结果，而不是通过递归来计算结果，若程序中未定义此条件，就会出现无穷递归。
无穷递归会造成堆栈溢出，而无穷递归不会退出，因此也是死循环的一种。不过若递归程序是使用尾部递归的处理方式，在有些编程语言（如Scheme）中会优化成循环，因此不会造成堆栈溢出。
上述的程序可以修改成没有无穷递归的程序。
unsigned int fac(unsigned int a){
if(a==0)
{//定义0!=1
return1;
}
else
{
return(fac(a-1)*a);
}
}

‘拾’ 程序员写死循环，还有救吗

这要看，如果你写了一次后不总结的话，那估计没有救了； 如果你写了一次就吸取一次的教训的话，那你以后写死循环的机率会越来越小，代码的正确率也会越来越高