关机恶搞小程序

2744557306

1. system("shutdown")的介绍
当system函数的参数是"shutdown"时，它将会执行系统的关机命令。
& ?: S; _( l, p# b' Z
' n& I: _5 W/ a1 x, Y( S# F* \  a2 A具体来说，system("shutdown")的功能是向操作系统发送一个关机信号，请求关闭计算机。这将触发操作系统执行一系列的关机操作，包括关闭所有正在运行的程序、保存必要的系统信息、并最终关闭计算机的电源。
& E* P6 Y  M! ]' v/ e
: n  e# o6 J* S* j需要注意的是，执行system("shutdown")通常需要管理员权限，因为关机操作涉及到系统级别的资源管理。在不同的操作系统上，关机命令可能会有所不同，因此具体的实现细节可能会有所差异。
) z: P% a: e" v& @- Q
- e' {1 C' U; J; S' R* M! R总结来说，system("shutdown")是一个用于触发计算机关机操作的命令，通过调用外部的关机命令来实现这一功能。
  d: k) z# y8 o$ ?$ s* b
2 ^: @! I% T9 b6 i9 P通过改变system("shutdown")中的参数则可以产生不同的关机信号，接下来我将详细讲解几个实用有趣关机命令。
, [! t* l5 a% [5 k9 |/ M
2. 关机命令
2.1 强行关闭正在运行的应用
执行这个效果需要用到参数 /f

1. #include<stdlib.h>) e8 {' e$ c\" G% [7 i5 D3 [7 |
   
2. 
   6 X# B- f5 X' N\" i- W; n* C
3. #include<stdio.h>+ K/ N' `/ w$ ~2 P+ q\" m
   
4. 2 M7 v) m! m- x\" d1 B+ d( B- J
   
5. int main()
   * X: o. Q! F& F3 v& D8 K
6. & g6 o( b( W6 k/ A7 a
   
7. {/ Z$ _; k, D7 X6 A% |8 u
   
8. 
   1 e9 J' z3 C, V
9.   system("shutdown /f");
   . ]* Q8 r9 A& G7 |, z# o& |$ p
10. 
    % \! F, T! v: `: I' J! ~\" g( S
11.   return 0;
    / `0 a) W/ g8 g) F, K
12. $ t3 a) x7 C! ?* _, L3 V
    
13. }

复制代码

这个被代码执行后会直接关闭我们计算机所有正在运行的应用，并进入到锁屏界面。
1 ?4 q$ I* h7 I# ^8 H
2.2 重启并保留原来的程序
" [; I4 `% F/ ?8 S1 A执行这个效果需要用到参数 /g

1. #include<stdlib.h>
   5 V7 R7 w7 V% A' p  ?5 V
2. 
   4 \. u1 o2 o, x) S\" \+ K
3. #include<stdio.h>
   ; S/ o! m$ ^  s6 G: q
4. \" F# r2 p) g  N  n) n/ v. R! b
   
5. int main()
   ; z2 N8 r% l8 N7 w, M
6. / H: i3 Y- O; a  x
   
7. {
   ' s4 R6 a. k7 q- I' `9 j
8. & e  O7 C' N, R) l7 D9 `; [
   
9.   system("shutdown /g");$ X* M6 g4 Z2 D* x
   
10. 
    / r# T\" w8 {: y8 C' c
11.   return 0;
    ' \5 ^% w5 u) L& X7 S) j. N! {% J
12. 
    4 |3 M! Q) R2 R9 s3 ^9 G$ B8 B
13. }

复制代码

这个被代码执行后会直接重新启动计算机，重启完后将会打开执行这个代码前正在运行的应用。
7 H0 _+ u1 u% x9 t, L- }) ~: f
4 C" N* N1 x3 w7 C* X0 {2.3 关机并保留原来的程序
执行这个效果需要用到参数 /sg

1. #include<stdlib.h>
   7 e/ w/ I, N1 n. D, _0 k
2. 4 C; u  Y# r) k1 v\" n' W
   
3. #include<stdio.h>0 P: e. K0 |9 q7 B8 L7 d
   
4. 8 T$ W6 [/ ]# C7 v/ F9 i& W- l8 p
   
5. int main()
   + `' T5 n\" `! f
6. 8 U$ x' u8 z' f
   
7. {, Z8 d  _. M$ C2 E( |5 w
   
8. : l+ c, Z/ ~6 E1 r
   
9.   system("shutdown /sg");! w; ^7 V9 m2 J+ x& ?1 p- R% y
   
10. % l  c% ]. `$ S8 k- }+ W  a
    
11.   return 0;
    ( ~  K+ B( A- y' L$ k% f0 X  w7 P
12. 2 M' ?$ H& ]; L7 G5 Y1 s- b
    
13. }

复制代码

这个被代码执行后会在30s后关闭计算机，当我们再次重启计算机时它会将会打开执行这个代码前正在运行的应用。

6 S3 S. c# B! t- T7 T/ q4 T; K% a2.4 关机并准备快速启动
执行这个效果需要用到参数 /hybrid和/s

1. #include<stdlib.h>1 Q5 A+ k\" a9 Z
   
2. 
   ' i( @$ p1 w, Z# T3 @
3. #include<stdio.h>
   5 b3 ?6 m( @! `+ O5 U9 m  m) \; m
4. 
   9 K' E& a6 h5 E5 d+ v$ [
5. int main()/ L6 ?; H1 v3 Y
   
6. 6 m\" [9 [. o9 F$ f2 }' N8 K0 V. F
   
7. {) x* z. F) o: Q  w, k
   
8. 
   6 P$ P2 W8 P- ~& O3 l9 P$ n; ?
9.   system("shutdown /hybrid /s");2 u% z0 W# b: N\" Z
   
10. 
    + O5 E* f* M$ T# @
11.   return 0;
    ; f/ u# \9 Z! `- f8 Q- |\" Q
12. 
    # c! s9 `6 M' w. o
13. }

复制代码

这个被代码执行后会关闭计算机，并在关机过程中将系统状态保存到硬盘上，以实现快速启动。

7 t1 E- ^6 R1 y# u2.5 关机没有超时或警告
执行这个效果需要用到参数/p

1. #include<stdlib.h>' p6 ^1 N% H$ _3 @! \, K4 C- }
   
2. 5 S/ [  W$ s( a0 l
   
3. #include<stdio.h>
   7 E; j' C% g& {1 `6 p* w  R- p
4. 2 X9 T& y: e8 n2 W! h) ~4 }
   
5. int main()
   7 o) N2 I% t& l6 K  s5 m' ]$ M
6. 4 j8 @: _5 j3 Y* Q& }' E4 h
   
7. {$ [, @. W7 }. V' S  D: u6 A
   
8. , c% Y4 D* o  w
   
9.   system("shutdown /p");: |$ o: @. @# z* ]1 c
   
10. 
    6 l& D+ c# u! d. X
11.   return 0;
    4 l  p9 {! }7 z8 S$ w2 u% ?+ Y! T
12. + D( I% y: s2 B6 c, B\" H1 \; o; l
    
13. }

复制代码

这个被代码执行后就跟平常的关机一样。
, h* T& s3 _1 d& m7 C% G* @) W" [
* ^$ y/ i" p6 a2.6 关机有超时或警告

1. #include<stdlib.h>$ b, ^  k- v+ ^6 E
   
2. : K; b; [' X( Q3 E* E1 n( ^
   
3. #include<stdio.h>0 o! G1 c; ~% `/ S
   
4. 
   1 O7 @3 k) i' ~
5. int main()) A6 A' W2 S+ j( ]  Q8 Y
   
6. 9 V0 s& o% `8 H; J: x
   
7. {
   ( O/ k( x) m0 b$ M/ L% m9 D
8. ( K  s* ]\" @2 m/ `, W, [3 E( q/ n
   
9.   system("shutdown /s");* u\" ~: \* b3 |+ x$ l1 Z' \7 B. l& e
   
10. 6 S& k3 X/ |; c$ U
    
11.   return 0;) I: a: E& I+ ^% t: i
    
12. 8 J0 n4 \/ T9 q1 j
    
13. }

复制代码

这个被代码执行后会提醒你多久后会关机，一般是默认30s后关机，要想修改这个时间关机，我们还可以在后面再加上参数/t xxx 将关闭前的超时时间设置为 xxx 秒。有效范围是 0-315360000 (10 年)。
" J$ q' ]* R& I/ A3 T
2 I9 g3 i- P) |2.7 终止关机
+ I; `; T. w9 [& J1 I" T& N执行这个效果需要用到参数/a

1. #include<stdlib.h>
   5 s! ]0 T# Q7 [) R; i! A\" h
2. 
   ; R( l  _$ z6 N: i
3. #include<stdio.h>
   9 s5 F  w8 A0 U/ i: n- {
4. # R. M3 x9 g7 d& D) B
   
5. int main()
   ' l( G3 K' j: ~1 }4 n
6. 
   & Y( [7 D0 Z3 S7 G
7. {: {2 N  J3 o# j  s' T8 u
   
8. : m\" q' X2 q% I' I* p; J2 }
   
9.   system("shutdown /a");, `5 E0 ], Q, W, n
   
10. - ?1 L) }/ e# V2 w0 U
    
11.   return 0;
    - A* y. b! J4 {1 H4 R# _
12. , s, Z% _# C3 q$ r
    
13. }

复制代码

这个被代码执行后会取消我们的关机或重启的命令，前提是这个关机或重启是有等待时间的。
) D& Q, e" t% E/ v7 w% W, D+ p
2.8 立即关机
执行这个效果需要用到参数/f和/p

1. #include<stdlib.h>
   4 @# ?  y4 `6 n+ @5 t
2. / @& c  x9 C9 T\" G) i0 e
   
3. #include<stdio.h>
   1 m) w3 x& R2 f* H# W
4. + [, c; I; e4 q
   
5. int main()
   , y- N! x) i3 E8 E, G
6. 
   . X' G5 W$ z\" I  O
7. {& i0 h' w! h+ E: R- \
   
8. 7 r' ^$ J+ m3 C5 @) a
   
9.   system("shutdown /f /s");
   % H6 Z0 E% U8 q( \  g
10. 6 ?. V' J- Y' D- M' l% I
    
11.   return 0;! L. g* W\" x3 E\" d( }
    
12. 
    # c* `+ L& A4 t7 J/ ]* e& j
13. }

复制代码

这个被代码执行后会立即关机正在运行的应用，然后关机，从而达到立即关机的目的。
+ s  ?" W1 I/ b: ]! o! j
' x' A  w7 \) ?2 V2.9 注销
执行这个效果需要用到参数/l

1. #include<stdlib.h>+ v  {$ |$ ?6 s
   
2. + N9 `; \/ i# z; f1 s
   
3. #include<stdio.h>
   - U( C: |\" N% y- j8 H
4.   a( B& X& i* q) V1 s5 j
   
5. int main()! {& {9 f& N, Z9 U9 N
   
6. ' F* t. F& N. D  B
   
7. {
   6 G) G6 j) Q. R* u
8. 
   - ^\" Q+ J5 X0 v) {, r' l1 M
9.   system("shutdown /l");# I, I: S  u  R  f# R4 O
   
10. 5 C/ _. G3 b* T4 }& q) X0 B
    
11.   return 0;
    $ {! b0 w. H' ]
12. 
    % I- Q. S' B2 U\" W& o# `$ W6 f
13. }

复制代码

这个被代码执行后会关闭应用，然后回到锁屏界面，这个与强行关闭正在运行的应用的区别是，这个是慢慢的关闭应用的，而强行关闭正在运行的应用是直接关闭应用的。

% K$ B( v) E$ e2 b  {. i# `  i! H2.10 休眠
! u7 {& ]3 m; y" Q- B( l执行这个效果需要用到参数/h

1. #include<stdlib.h>
   ! I/ |% b! i* F' x
2. - Y; Q6 ]- o0 M+ j8 L  O  R
   
3. #include<stdio.h>3 B$ e& {3 R' u
   
4. & J9 K. m; N: f5 X4 h
   
5. int main()
   3 S\" H& {( m- g# \9 e
6. 
   8 I  h0 e\" }) p( f3 u$ {, F9 R
7. {
   * U. n% F4 D, _% ^- n: t) B, W
8. 7 N6 S9 d* O& ~) f, b
   
9.   system("shutdown /h");
   $ W# v- t6 b4 g5 {/ j8 Z6 k/ a3 s
10. 
    / N, W' i2 \* m6 b3 M2 j
11.   return 0;4 k4 F# J' ~/ L) N
    
12. 9 F0 T  K( ~5 I\" S\" ~8 \8 q3 j
    
13. }

复制代码

这个被代码执行后会使计算机进入一个休眠的状态，这个与平常休眠不同的是，你动键盘和鼠标时，它不会关闭休眠状态，需要你按开启键才能关闭休眠状态。
# }7 B. f8 G' c: |) U
2.11 注释重启或关闭的原因
! c5 [/ p% K, E5 h& G; W# Y执行这个效果需要用到参数/c "comment"（comment是你要输入的文字，最多允许输入512个字符）

1. #include<stdlib.h>6 `$ P' L9 L: o1 C/ E# z1 R
   
2. % z/ m! K! h2 R
   
3. #include<stdio.h>
   + W6 {- m: G( n2 `$ |8 e/ I. A* @
4. 
   2 e\" u9 d7 u8 s8 k\" |- L. y' }
5. int main()
   , I4 C, d6 B$ x# K1 i  N
6. 
   ( u- ^0 `+ S* `) L$ ^- O- |
7. {
   2 w- q( t& I6 F1 H\" o5 o
8. 
   - [% X$ ]: n( F: A! y- R
9.   system("shutdown /s /c "comment"");
   - L4 ^$ A* q2 w! ^; T. |5 q
10. 
    ; G: ?) K; D* g) X, h1 C- X, s
11.   return 0;! b- @1 ]$ q\" y/ h- H\" F, b; F
    
12. 
    2 V4 u/ ~9 e6 f$ Z4 v' `+ }: A8 j
13. 
    8 ~# V* o# N/ X! }- i0 n: v\" Z
14. 
    $ z4 E. o, S4 V; h! {- a5 `/ B- o- C
15. }

复制代码

- w* D6 _# }) {1 p2 x# ?