js 画图

原生js画图

<html> 
<head> 
<meta http-equiv="Content-Type" content="text/html; charset=utf8"> 
<title>js 画图</title> 
</head> 
<body> 
  <button onclick="testDrawCurve()">画曲线</button> 
  <button onclick="testDrawArc()">画弧线</button> 
  <button onclick="testDrawCircle()">画圆</button> 
  <button onclick="testDrawLine()">画线</button> 
  <button onclick="testDrawRectangle()">画矩形</button> 
  <button onclick="testDrawSector()">画扇形</button> 

  <div id="canvas"></div> 

<script type="text/javascript">
var div1 = document.getElementById("canvas");
// 画曲线测试
function testDrawCurve()
{
  div1.innerHTML = drawCurve(); 
}

// 画弧线测试
function testDrawArc()
{
  div1.innerHTML =drawArc(150,150,100,0,270,"blue")
}

// 画圆测试
function testDrawCircle()
{
  div1.innerHTML = drawCircle(200,200,150,"blue"); 
} 

// 画线测试
function testDrawLine()
{
  div1.innerHTML = drawLine(100,200,500,200,"yellow")+drawLine(300,100,300,400,"black")+drawLine(600,400,100,100,"violet")
}

// 画圆
function drawCircle(x0,y0,radius,color) 
{ 
  return drawArc(x0,y0,radius,0,360,color)
}

// 画矩形测试
function testDrawRectangle()
{
  div1.innerHTML = drawRectangle(200,100,600,200,"blue")+drawRectangle(100,200,400,500,"red")
}

// 画扇形测试
function testDrawSector()
{
  div1.innerHTML = drawSector(300,200,120,0,45,"red"); 
} 


/*
  画线
*/
function drawLine(x0,y0,x1,y1,color) 
{ 
  var rs = ""; 
  if (y0 == y1)  //画横线 
  { 
  if (x0>x1){var t=x0;x0=x1;x1=t}   
  rs = "<span style='top:"+y0+";left:"+x0+";position:absolute;font-size:1px;background-color:"+color+";height:1; width:"+Math.abs(x1-x0)+"'></span>"; 
  } 
  else if (x0 == x1)  //画竖线 
  { 
  if (y0>y1){var t=y0;y0=y1;y1=t}  
  rs = "<span style='top:"+y0+";left:"+x0+";position:absolute;font-size:1px;background-color:"+color+";width:1;height:"+Math.abs(y1-y0)+"'></span>"; 
  } 
  else 
  { 
    var lx = x1-x0
    var ly = y1-y0
    var l = Math.sqrt(lx*lx+ly*ly)
    rs = new Array(); 
    for (var i=0;i<l;i+=1) 
    { 
      var p = i/l; 
      var px = parseInt(x0 + lx*p); 
      var py = parseInt(y0 + ly*p); 
      rs[rs.length] = "<span style='top:"+py+";left:"+px+";height:1;width:1;position:absolute;font-size:1px;background-color:"+color+"'></span>"; 
    } 
    rs = rs.join(""); 
  } 
  return rs 
} 

/*
  画矩形
*/
function drawRectangle(x0,y0,x1,y1,color) 
{ 
  if (x0 == x1 || y0 == y1) return; 
  if (x0>x1) {var t=x0;x0=x1;x1=t} 
  if (y0>y1) {var t=y0;y0=y1;y1=t} 
  return "<table style='top:"+y0+";left:"+x0+";position:absolute'><td bgcolor="+color+" width="+(x1-x0)+" height="+(y1-y0)+"></td></table>"; 
} 

/*
  画扇形
*/
function drawSector(x0,y0,radius,startAngle,endAngle,color) 
{ 
  var rs = drawArc(x0,y0,radius,startAngle,endAngle,color);
  startAngle = startAngle/360*Math.PI*2; 
  endAngle = endAngle/360*Math.PI*2; 
  var startx=Math.sin(startAngle)*radius+x0; 
  var endx=Math.sin(endAngle)*radius+x0; 
  var starty=Math.cos(startAngle)*radius+y0; 
  var endy=Math.cos(endAngle)*radius+y0; 
  rs += drawLine(x0,y0,startx,starty,color);
  rs += drawLine(x0,y0,endx,endy,color);
  return rs; 
}

/*
  画弧线
*/
function drawArc(x0,y0,radius,startAngle,endAngle,color) 
{ 
  rs = new Array(); 
  tmpar = new Array(); 
  startAngle = startAngle/360*Math.PI*2; 
  endAngle = endAngle/360*Math.PI*2; 
  for (var i=startAngle;i<endAngle;i+=(1/radius))
  { 
    var dx = parseInt(Math.sin(i)*radius+x0); 
    var dy = parseInt(Math.cos(i)*radius+y0); 
    rs[rs.length] = "<span style='top:"+dy+";left:"+dx+";position:absolute;height:1;width:1;position:absolute;font-size:1px;background-color:"+color+"'></span>"; 
  } 
  return (rs.join("")); 
}

/*
  画曲线
*/
function drawCurve()
{
  var rs = new Array();
  for (var i=0;i<2*Math.PI;i+=.01)
  { 
    var x = parseInt(300-Math.sin(i)*100);
    var y = parseInt(300-Math.cos(i)*100);
    rs[rs.length] = "<span style='top:"+x+";left:"+(i*100+190)+" ;height:1;width:1;position:absolute;font-size:1px;background-color:blue'></span>"; 
    rs[rs.length] = "<span style='top:"+y+";left:"+(i*100+190)+" ;height:1;width:1;position:absolute;font-size:1px;background-color:blue'></span>"; 
  } 
  return rs.join(""); 
} 
</script> 

<!-- font-size:1px; for IE 6 -->
</body> 
</html>

end.x) {
var t = start.x;
start.x = end.x;
end.x = t;
}
rs = ““;
}
else if( start.x == end.x) //画竖线
{
if( start.y > end.y) {
var t = start.y;
start.y = end.y;
end.y = t;
}
rs = ““;
}else
{
var lx = end.x-start.x;
var ly = end.y-start.y;
var l = Math.sqrt(lx*lx+ly*ly);
rs = new Array();
for (var i=0;i<l;i+=1)
{
var p = i/l;
var px = parseInt(start.x + lx*p);
var py = parseInt(start.y + ly*p);
rs[rs.length] = "“;
}
rs = rs.join(“”);
}
$(“#canvas”).append(rs);
}

drawLine( {x:10,y:49}, {x:120,y:59}, “skyblue”);
–>

WordPress 如何添加新浪微博秀

1.获取新浪微博秀代码

地址:http://app.weibo.com/tool/weiboshow

2.找到wordpress后台外观小工具

3.拖动文本插件到合适的位置

即图中 “任意文本或 HTML” 的文本插件,拖动到右侧的 MainSidebar(主体侧边栏)或者希望出现在网站的其他位置也可以拖动到相应的区域中。

4.添加代码到文本插件

新浪app处复制的微博秀代码粘贴到其中、保存 ok 你可以刷新网站的首页了。

C标准库 ctype.h (一) _Ctype转换表原理

简述

P.J.Plauger版本 C标准库 Ctype 中判断字符是否属于某个类型,主要是通过转换表来实现的。

以判断是否为小写字母为例

ctype.h 头文件

/* ctype.h */

#ifndef _CTYPE
#define _CTYPE

/* _Ctype 转换位 */
#define _XA	0x200	/* extra alphabetic */
#define _XS	0x100	/* extra space */
#define _BB	0x80	/* BEL, BS, etc. */
#define _CN	0x40	/* CR, FF, HT, NL, VT */
#define _DI	0x20	/* '0' - '9' */
#define _LO	0x10	/* 'a' - 'z' */
#define _PU	0x08	/* punctuation */
#define _SP	0x04	/* space */
#define _UP	0x02	/* 'A' - 'Z' */
#define _XD	0x01	/* '0' - '9', 'A' - 'F', 'a' - 'f' */

/* 声明外部的 _Ctype 转换表 */
extern const short *_Ctype;

/* 判断是否为小写字母的带参数宏 islower */
#define islower(c) (_Ctype[(int)(c)] & _LO)

// 其余省略 ...

#endif

_Ctype 转换表

/* xctype.c _Ctype 转换表 -- ASCII 版 */
#include <limits.h>
#include <stdio.h>
#include "ctype.h"

#if EOF != -1 || UCHAR_MAX != 255
#error WRONG CTYPE table
#endif

/* 组合位 */ 
#define XDI (_DI|_XD)
#define XLO (_LO|_XD)
#define XUP (_UP|_XD)

/* 转换表 */
static const short ctype_tab[257] = { 0, /* EOF */
	_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
	_BB, _CN, _CN, _CN, _CN, _CN, _BB, _BB,
	_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
	_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
	_SP, _PU, _PU, _PU, _PU, _PU, _PU, _PU,
	_PU, _PU, _PU, _PU, _PU, _PU, _PU, _PU,
	XDI, XDI, XDI, XDI, XDI, XDI, XDI, XDI,
	XDI, XDI, _PU, _PU, _PU, _PU, _PU, _PU,
	_PU, XUP, XUP, XUP, XUP, XUP, XUP, _UP,
	_UP, _UP, _UP, _UP, _UP, _UP, _UP, _UP,
	_UP, _UP, _UP, _UP, _UP, _UP, _UP, _UP,
	_UP, _UP, _UP, _PU, _PU, _PU, _PU, _PU,
	_PU, XLO, XLO, XLO, XLO, XLO, XLO, _LO,
	_LO, _LO, _LO, _LO, _LO, _LO, _LO, _LO,
	_LO, _LO, _LO, _LO, _LO, _LO, _LO, _LO,
	_LO, _LO, _LO, _PU, _PU, _PU, _PU, _BB,
};

const short *_Ctype = &ctype_tab[1];

调用过程

#include <stdio.h>
#include "ctype.h"

void test(char c)
{
	if( islower(c) != 0 )
		printf("%c 是小写字母n", c);
	else
		printf("%c 不是小写字母n", c);
}

int main()
{
	int i;
	// 遍历ASCII码表128个字符判断是否为小写字母
	for(i=0; i<128; i++)
	{
		test(i);
	}
	return 0;
}

中间判断的过程其实很简单,首先islower 是个带参数宏

预处理之后,假设当前的c是’a’那么变成了:

(_Ctype[(int)('a')] & _LO)

字符’a’的值为97所以接下来便是:

(_Ctype[97] & _LO)

_Ctype[97]的转换宏是 _LO 大家可以对找下方的 _Ctype 转换表, _LO 的值又是 0x10,所以最后是:

(_LO & _LO)   ---->    0x10 & 0x10    ---->    1    当前字符为小写字母

& 运算就不说了,详细请百度“按位与”

结果就不放上来了,大家自行实验。

table td, th{
text-align: center;
}
.bb{ color:yellow; }
.cn{ color:green; }
.di{ color:blue; }
.lo{ color:red; }
.pu{ color:orange; }
/*.sp{ color:; }*/
.up{ color:#F076BF; }
.xd{ color:skyblue; }

_Ctype 转换位

转表宏 二进制 十进制 十六进制 对应字符
_BB 1000 0000 128 0x80 BEL, BS, etc.
_CN 0100 0000 64 0x40 CR, FF, HT, NL, VT
_DI 0010 0000 32 0x20 ‘0’ – ‘9’
_LO 0001 0000 16 0x10 ‘a’ – ‘z’
_PU 0000 1000 8 0x08 标点符号
_SP 0000 0100 4 0x04 空格
_UP 0000 0010 2 0x02 ‘A’ – ‘Z’
_XD 0000 0001 1 0x01 ‘0’ – ‘9’, ‘A’ – ‘F’, ‘a’ – ‘f’

通过按位与上对应的宏,就可以检查该字符在转换表中对应的转表宏,二者按位与:
如与上 _LO 其值为 0001 0000,计算的时候,0与上任何数均为0,对应位全部被清零
仅保留第5位(1与上1为1,1与上0为0),所以如果只有两种结果,一个是第5位为真(16)或者为假即为0

_Ctype 转换表

二进制 十进制 十六进制 转表宏 二进制 十进制 十六进制 ASCII值
0000 0000 0 0x00 _BB 1000 0000 128 0x80 空字符(Null)
0000 0001 1 0x01 _BB 1000 0000 128 0x80 标题开始
0000 0010 2 0x02 _BB 1000 0000 128 0x80 本文开始
0000 0011 3 0x03 _BB 1000 0000 128 0x80 本文结束
0000 0100 4 0x04 _BB 1000 0000 128 0x80 传输结束
0000 0101 5 0x05 _BB 1000 0000 128 0x80 请求
0000 0110 6 0x06 _BB 1000 0000 128 0x80 确认回应
0000 0111 7 0x07 _BB 1000 0000 128 0x80 响铃
0000 1000 8 0x08 _BB 1000 0000 128 0x80 退格
0000 1001 9 0x09 _CN 0100 0000 64 0x40 水平定位符号
0000 1010 10 0x0A _CN 0100 0000 64 0x40 换行键
0000 1011 11 0x0B _CN 0100 0000 64 0x40 垂直定位符号
0000 1100 12 0x0C _CN 0100 0000 64 0x40 换页键
0000 1101 13 0x0D _CN 0100 0000 64 0x40 Enter键
0000 1110 14 0x0E _BB 1000 0000 128 0x80 取消变换(Shift out)
0000 1111 15 0x0F _BB 1000 0000 128 0x80 启用变换(Shift in)
0001 0000 16 0x10 _BB 1000 0000 128 0x80 跳出数据通讯
0001 0001 17 0x11 _BB 1000 0000 128 0x80 设备控制一(XON 激活软件速度控制)
0001 0010 18 0x12 _BB 1000 0000 128 0x80 设备控制二
0001 0011 19 0x13 _BB 1000 0000 128 0x80 设备控制三(XOFF 停用软件速度控制)
0001 0100 20 0x14 _BB 1000 0000 128 0x80 设备控制四
0001 0101 21 0x15 _BB 1000 0000 128 0x80 确认失败回应
0001 0110 22 0x16 _BB 1000 0000 128 0x80 同步用暂停
0001 0111 23 0x17 _BB 1000 0000 128 0x80 区块传输结束
0001 1000 24 0x18 _BB 1000 0000 128 0x80 取消
0001 1001 25 0x19 _BB 1000 0000 128 0x80 连接介质中断
0001 1010 26 0x1A _BB 1000 0000 128 0x80 替换
0001 1011 27 0x1B _BB 1000 0000 128 0x80 退出键
0001 1100 28 0x1C _BB 1000 0000 128 0x80 文件分区符
0001 1101 29 0x1D _BB 1000 0000 128 0x80 组群分隔符
0001 1110 30 0x1E _BB 1000 0000 128 0x80 记录分隔符
0001 1111 31 0x1F _BB 1000 0000 128 0x80 单元分隔符
0010 0000 32 0x20 _SP 0000 0100 4 0x04 (空格,␠)
0010 0001 33 0x21 _PU 0000 1000 8 0x08 !
0010 0010 34 0x22 _PU 0000 1000 8 0x08
0010 0011 35 0x23 _PU 0000 1000 8 0x08 #
0010 0100 36 0x24 _PU 0000 1000 8 0x08 $
0010 0101 37 0x25 _PU 0000 1000 8 0x08 %
0010 0110 38 0x26 _PU 0000 1000 8 0x08 &
0010 0111 39 0x27 _PU 0000 1000 8 0x08
0010 1000 40 0x28 _PU 0000 1000 8 0x08 (
0010 1001 41 0x29 _PU 0000 1000 8 0x08 )
0010 1010 42 0x2A _PU 0000 1000 8 0x08 *
0010 1011 43 0x2B _PU 0000 1000 8 0x08 +
0010 1100 44 0x2C _PU 0000 1000 8 0x08 ,
0010 1101 45 0x2D _PU 0000 1000 8 0x08
0010 1110 46 0x2E _PU 0000 1000 8 0x08 .
0010 1111 47 0x2F _PU 0000 1000 8 0x08 /
0011 0000 48 0x30 XDI 0010 0001 33 0x21 0
0011 0001 49 0x31 XDI 0010 0001 33 0x21 1
0011 0010 50 0x32 XDI 0010 0001 33 0x21 2
0011 0011 51 0x33 XDI 0010 0001 33 0x21 3
0011 0100 52 0x34 XDI 0010 0001 33 0x21 4
0011 0101 53 0x35 XDI 0010 0001 33 0x21 5
0011 0110 54 0x36 XDI 0010 0001 33 0x21 6
0011 0111 55 0x37 XDI 0010 0001 33 0x21 7
0011 1000 56 0x38 XDI 0010 0001 33 0x21 8
0011 1001 57 0x39 XDI 0010 0001 33 0x21 9
0011 1010 58 0x3A _PU 0000 1000 8 0x08 :
0011 1011 59 0x3B _PU 0000 1000 8 0x08 ;
0011 1100 60 0x3C _PU 0000 1000 8 0x08 <
0011 1101 61 0x3D _PU 0000 1000 8 0x08 =
0011 1110 62 0x3E _PU 0000 1000 8 0x08 >
0011 1111 63 0x3F _PU 0000 1000 8 0x08 ?
0100 0000 64 0x40 _PU 0000 1000 8 0x08 @
0100 0001 65 0x41 XUP 0000 0011 3 0x03 A
0100 0010 66 0x42 XUP 0000 0011 3 0x03 B
0100 0011 67 0x43 XUP 0000 0011 3 0x03 C
0100 0100 68 0x44 XUP 0000 0011 3 0x03 D
0100 0101 69 0x45 XUP 0000 0011 3 0x03 E
0100 0110 70 0x46 XUP 0000 0011 3 0x03 F
0100 0111 71 0x47 _UP 0000 0010 2 0x02 G
0100 1000 72 0x48 _UP 0000 0010 2 0x02 H
0100 1001 73 0x49 _UP 0000 0010 2 0x02 I
0100 1010 74 0x4A _UP 0000 0010 2 0x02 J
0100 1011 75 0x4B _UP 0000 0010 2 0x02 K
0100 1100 76 0x4C _UP 0000 0010 2 0x02 L
0100 1101 77 0x4D _UP 0000 0010 2 0x02 M
0100 1110 78 0x4E _UP 0000 0010 2 0x02 N
0100 1111 79 0x4F _UP 0000 0010 2 0x02 O
0101 0000 80 0x50 _UP 0000 0010 2 0x02 P
0101 0001 81 0x51 _UP 0000 0010 2 0x02 Q
0101 0010 82 0x52 _UP 0000 0010 2 0x02 R
0101 0011 83 0x53 _UP 0000 0010 2 0x02 S
0101 0100 84 0x54 _UP 0000 0010 2 0x02 T
0101 0101 85 0x55 _UP 0000 0010 2 0x02 U
0101 0110 86 0x56 _UP 0000 0010 2 0x02 V
0101 0111 87 0x57 _UP 0000 0010 2 0x02 W
0101 1000 88 0x58 _UP 0000 0010 2 0x02 X
0101 1001 89 0x59 _UP 0000 0010 2 0x02 Y
0101 1010 90 0x5A _UP 0000 0010 2 0x02 Z
0101 1011 91 0x5B _PU 0000 1000 8 0x08 [
0101 1100 92 0x5C _PU 0000 1000 8 0x08
0101 1101 93 0x5D _PU 0000 1000 8 0x08 ]
0101 1110 94 0x5E _PU 0000 1000 8 0x08 ^
0101 1111 95 0x5F _PU 0000 1000 8 0x08 _
0110 0000 96 0x60 _PU 0000 1000 8 0x08 `
0110 0001 97 0x61 XLO 0001 0001 17 0x11 a
0110 0010 98 0x62 XLO 0001 0001 17 0x11 b
0110 0011 99 0x63 XLO 0001 0001 17 0x11 c
0110 0100 100 0x64 XLO 0001 0001 17 0x11 d
0110 0101 101 0x65 XLO 0001 0001 17 0x11 e
0110 0110 102 0x66 XLO 0001 0001 17 0x11 f
0110 0111 103 0x67 _LO 0001 0000 16 0x10 g
0110 1000 104 0x68 _LO 0001 0000 16 0x10 h
0110 1001 105 0x69 _LO 0001 0000 16 0x10 i
0110 1010 106 0x6A _LO 0001 0000 16 0x10 j
0110 1011 107 0x6B _LO 0001 0000 16 0x10 k
0110 1100 108 0x6C _LO 0001 0000 16 0x10 l
0110 1101 109 0x6D _LO 0001 0000 16 0x10 m
0110 1110 110 0x6E _LO 0001 0000 16 0x10 n
0110 1111 111 0x6F _LO 0001 0000 16 0x10 o
0111 0000 112 0x70 _LO 0001 0000 16 0x10 p
0111 0001 113 0x71 _LO 0001 0000 16 0x10 q
0111 0010 114 0x72 _LO 0001 0000 16 0x10 r
0111 0011 115 0x73 _LO 0001 0000 16 0x10 s
0111 0100 116 0x74 _LO 0001 0000 16 0x10 t
0111 0101 117 0x75 _LO 0001 0000 16 0x10 u
0111 0110 118 0x76 _LO 0001 0000 16 0x10 v
0111 0111 119 0x77 _LO 0001 0000 16 0x10 w
0111 1000 120 0x78 _LO 0001 0000 16 0x10 x
0111 1001 121 0x79 _LO 0001 0000 16 0x10 y
0111 1010 122 0x7A _LO 0001 0000 16 0x10 z
0111 1011 123 0x7B _PU 0000 1000 8 0x08 {
0111 1100 124 0x7C _PU 0000 1000 8 0x08 |
0111 1101 125 0x7D _PU 0000 1000 8 0x08 }
0111 1110 126 0x7E _PU 0000 1000 8 0x08 ~
0111 1111 127 0x7F _BB 1000 0000 128 0x80 删除

微软 CL.exe 编译器

下载地址:
微软C语言编译器 CL.exe 32位 英文
微软C语言编译器 CL.exe 64位 中文

C/C++ 编译器选项
用于 x64 的 Microsoft (R) C/C++ 优化编译器 16.00.40219.01 版

优化

/O1 最小化空间
/O2 最大化速度
/Ob 内联扩展(默认 n=0)
/Od 禁用优化(默认)
/Og 启用全局优化
/Oi[-] 启用内部函数
/Os 优选代码空间
/Ot 优选代码速度
/Ox 最大化优化
/favor: 选择优化所针对的处理器,为以下值之一:
    blend - 针对几种不同 x64 处理器的优化组合
    AMD64 - 64 位 AMD 处理器
    INTEL64 - Intel(R)64 架构处理器

代码生成

/GF 启用只读字符串池
/Gm[-] 启用最小重新生成
/Gy[-] 分隔链接器函数
/GS[-] 启用安全检查
/GR[-] 启用 C++ RTTI
/GX[-] 启用 C++ EH (与 /EHsc 相同)
/EHs 启用 C++ EH (没有 SEH 异常)
/EHa 启用 C++ EH (w/ SEH 异常)
/EHc 外部“C”默认为 nothrow
/fp: 选择浮点模式:
    except[-] - 在生成代码时考虑浮点异常
    fast -“fast”浮点模式;结果可预测性比较低
    precise -“precise”浮点模式;结果可预测
    strict -“strict” 浮点模式(意味着 /fp:except)

即使使用 /fp:except,/Qfast_transcendentals 也生成内联内部 FP

/GL[-] 启用链接时代码生成
/GA 为 Windows 应用程序进行优化
/Ge 对所有函数强制堆栈检查
/Gs[num] 控制堆栈检查调用
/Gh 启用 _penter 函数调用
/GH 启用 _pexit 函数调用
/GT 生成纤程安全 TLS 访问
/RTC1 启用快速检查(/RTCsu)
/RTCc 转换为较小的类型检查
/RTCs 堆栈帧运行时检查
/RTCu 未初始化的局部用法检查
/clr[:option] 为公共语言运行时编译,其中 option 是:
    pure - 生成只包含 IL 的输出文件(没有本机可执行代码)
    safe - 生成只包含 IL 的可验证输出文件
    oldSyntax - 接受 Visual C++ 2002/2003 的托管扩展语法
    initialAppDomain - 启用 Visual C++ 2002 的初始 AppDomain 行为
    noAssembly - 不产生程序集
/homeparams 强制将传入寄存器的参数写入到堆栈中
/GZ 启用堆栈检查(/RTCs)
/arch:AVX 支持使用 Intel(R) 高级矢量扩展指令

输出文件

/Fa[file] 命名程序集列表文件
/FA[scu] 配置程序集列表
/Fd[file] 命名 .PDB 文件
/Fe 命名可执行文件
/Fm[file] 命名映射文件
/Fo 命名对象文件
/Fp 命名预编译头文件
/Fr[file] 命名源浏览器文件
/FR[file] 命名扩展 .SBR 文件
/Fi[file] 命名预处理的文件
/doc[file] 处理 XML 文档注释,并可选择命名 .xdc 文件

预处理器

(按回车键继续)
/AI 添加到程序集搜索路径
/FU 强制使用程序集/模块
/C 不抽出注释
/D{=|#} 定义宏
/E 预处理到 stdout
/EP 预处理到 stdout,无行号
/P 预处理到文件
/Fx 将插入的代码合并到文件中
/FI 命名强制包含文件
/U 移除预定义的宏
/u 移除所有预定义的宏
/I 添加到包含搜索路径
/X 忽略“标准位置”

语言

/Zi 启用调试信息
/Z7 启用旧式调试信息
/Zp[n] 在 n 字节边界上包装结构
/Za 禁用扩展
/Ze 启用扩展(默认)
/Zl 省略 .OBJ 中的默认库名
/Zg 生成函数原型
/Zs 只进行语法检查
/vd{0|1|2} 禁用/启用 vtordisp
/vm 指向成员的指针类型
/Zc:arg1[,arg2] C++ 语言合规性,这里的参数可以是:
    forScope[-] - 对范围规则强制使用标准 C++
    wchar_t[-] - wchar_t 是本机类型,不是 typedef
    auto[-] - 对 auto 强制使用新的标准 C++ 含义
    trigraphs[-] - 启用三元祖(默认为关闭)
/openmp 启用 OpenMP 2.0 语言扩展

杂项

@ 选项响应文件
/?, /help 打印此帮助消息
/bigobj 生成扩展的对象格式
/c 只编译,不链接
/errorReport:option 将内部编译器错误报告给 Microsoft
    none - 不发送报告                       prompt - 提示立即发送报告
    queue - 在下一次管理员登录时,提示发送报告(默认)
    send - 自动发送报告 /FC 诊断中使用完整路径名
/H 最大外部名称长度
/J 默认 char 类型是 unsigned
/MP[n] 最多使用“n”个进程进行编译
/nologo 取消显示版权信息
/showIncludes 显示包含文件名
/Tc 将文件编译为 .c
/Tp 将文件编译为 .cpp
/TC 将所有文件编译为 .c
/TP 将所有文件编译为 .cpp
/V 设置版本字符串
/w 禁用所有警告
/wd 禁用警告 n
/we 将警告 n 视为错误
/wo 发出一次警告 n
/w 为 n 设置警告等级 1-4
/W 设置警告等级(默认 n=1)
/Wall 启用所有警告
/WL 启用单行诊断
/WX 将警告视为错误
/Yc[file] 创建 .PCH 文件
/Yd 将调试信息放在每个 .OBJ 中
/Yl[sym] 为调试库插入 .PCH 引用
/Yu[file] 使用 .PCH 文件
/Y- 禁用所有 PCH 选项
/Zm 最大内存分配(默认为 %)
/Wp64 启用 64 位端口定位警告

链接

/LD 创建 .DLL
/LDd 创建 .DLL 调试库
/LN 创建 .netmodule
/F 设置堆栈大小
/link [链接器选项和库]
/MD 与 MSVCRT.LIB 链接
/MT 与 LIBCMT.LIB 链接
/MDd 与 MSVCRTD.LIB 调试库链接
/MTd 与 LIBCMTD.LIB 调试库链接

C标准库 string.h (四) 其他函数

string.h 其他函数

  • memset 设置某个范围内每字节的值
  • strlen 获取字符串长度
  • strerror 输出对应的错误信息

memset

memory set

设置某个范围内每字节的值,通常用来清空结构体或者清空某块内存。


#include <stdio.h>
#include <string.h>
#include <malloc.h>	// for malloc

/*
	标准库
*/
void *memset(void *s, int c, size_t n)
{
	const unsigned char uc = c;
	unsigned char *su;

	for (su = s; 0 < n; ++su, --n)
		*su = uc;
	return (s);
}

int main(int argc, char const *argv[])
{
	char *p = (char *)malloc(sizeof(char)*10); // 获取10字节的内存
	memset(p, 0, sizeof(char)*10);	// 将该10字节内存全部初始化为0
	return 0;
}

strlen

string length

获取字符串长度


#include <stdio.h>
#include <string.h>

/*
	自实现
*/
int _strlen(const char *dest)
{
	const char *start = dest;
	while(*dest)
		dest++;
	return (dest - start);
}

/*
	标准库
*/
int strlen(const char *s)
{
	const char *sc;

	for (sc = s; *sc != '\0'; ++sc)
		;
	return (sc - s);
}

int main(int argc, char const *argv[])
{
	printf("length : %dn", _strlen("hello world"));
	return 0;
}

strerror

string error

根据错误号输出错误信息


#include <stdio.h>
#include <errno.h>
#include <string.h>

/*
	标准库

char *_Strerror(int errcode, char *buf)
{
	static char sbuf[] = {"error #xxx"};

	if (buf == NULL)
		buf = sbuf;

	switch(errcode)
	{
		case 0:
			return ("no error");
		case EDOM:
			return ("domain error");
		case ERANGE:
			return ("range error");
		case EFPOS:
			return ("file positioning error");
		default:
			if(errcode < 0 || _NERR <= errcode)
				return ("unknown error");
			else
			{
				strcpy(buf, "error #xxx");
				buf[9] = errcode % 10 + '0';
				buf[8] = (errcode /= 10) % 10 + '0';
				buf[7] = (errcode / 10) % 10 + '0';
				return (buf);
			}
	}
}
*/

/*
	自实现
*/
char *_Strerror(int errcode, char *buf)
{
	static char sbuf[] = {"Unknown error xxx"};

	if (buf == NULL)
		buf = sbuf;

	switch(errcode)
	{
		case 0 :
			return ("Success");
		break;
		case 1 :
			return ("Operation not permitted");
		break;
		case 2 :
			return ("No such file or directory");
		break;
		case 3 :
			return ("No such process");
		break;
		case 4 :
			return ("Interrupted system call");
		break;
		case 5 :
			return ("Input/output error");
		break;
		case 6 :
			return ("No such device or address");
		break;
		case 7 :
			return ("Argument list too long");
		break;
		case 8 :
			return ("Exec format error");
		break;
		case 9 :
			return ("Bad file descriptor");
		break;
		case 10 :
			return ("No child processes");
		break;
		case 11 :
			return ("Resource temporarily unavailable");
		break;
		case 12 :
			return ("Cannot allocate memory");
		break;
		case 13 :
			return ("Permission denied");
		break;
		case 14 :
			return ("Bad address");
		break;
		case 15 :
			return ("Block device required");
		break;
		case 16 :
			return ("Device or resource busy");
		break;
		case 17 :
			return ("File exists");
		break;
		case 18 :
			return ("Invalid cross-device link");
		break;
		case 19 :
			return ("No such device");
		break;
		case 20 :
			return ("Not a directory");
		break;
		case 21 :
			return ("Is a directory");
		break;
		case 22 :
			return ("Invalid argument");
		break;
		case 23 :
			return ("Too many open files in system");
		break;
		case 24 :
			return ("Too many open files");
		break;
		case 25 :
			return ("Inappropriate ioctl for device");
		break;
		case 26 :
			return ("Text file busy");
		break;
		case 27 :
			return ("File too large");
		break;
		case 28 :
			return ("No space left on device");
		break;
		case 29 :
			return ("Illegal seek");
		break;
		case 30 :
			return ("Read-only file system");
		break;
		case 31 :
			return ("Too many links");
		break;
		case 32 :
			return ("Broken pipe");
		break;
		case 33 :
			return ("Numerical argument out of domain");
		break;
		case 34 :
			return ("Numerical result out of range");
		break;
		case 35 :
			return ("Resource deadlock avoided");
		break;
		case 36 :
			return ("File name too long");
		break;
		case 37 :
			return ("No locks available");
		break;
		case 38 :
			return ("Function not implemented");
		break;
		case 39 :
			return ("Directory not empty");
		break;
		case 40 :
			return ("Too many levels of symbolic links");
		break;
		case 41 :
			return ("Unknown error 41");
		break;
		case 42 :
			return ("No message of desired type");
		break;
		case 43 :
			return ("Identifier removed");
		break;
		case 44 :
			return ("Channel number out of range");
		break;
		case 45 :
			return ("Level 2 not synchronized");
		break;
		case 46 :
			return ("Level 3 halted");
		break;
		case 47 :
			return ("Level 3 reset");
		break;
		case 48 :
			return ("Link number out of range");
		break;
		case 49 :
			return ("Protocol driver not attached");
		break;
		case 50 :
			return ("No CSI structure available");
		break;
		case 51 :
			return ("Level 2 halted");
		break;
		case 52 :
			return ("Invalid exchange");
		break;
		case 53 :
			return ("Invalid request descriptor");
		break;
		case 54 :
			return ("Exchange full");
		break;
		case 55 :
			return ("No anode");
		break;
		case 56 :
			return ("Invalid request code");
		break;
		case 57 :
			return ("Invalid slot");
		break;
		case 58 :
			return ("Unknown error 58");
		break;
		case 59 :
			return ("Bad font file format");
		break;
		case 60 :
			return ("Device not a stream");
		break;
		case 61 :
			return ("No data available");
		break;
		case 62 :
			return ("Timer expired");
		break;
		case 63 :
			return ("Out of streams resources");
		break;
		case 64 :
			return ("Machine is not on the network");
		break;
		case 65 :
			return ("Package not installed");
		break;
		case 66 :
			return ("Object is remote");
		break;
		case 67 :
			return ("Link has been severed");
		break;
		case 68 :
			return ("Advertise error");
		break;
		case 69 :
			return ("Srmount error");
		break;
		case 70 :
			return ("Communication error on send");
		break;
		case 71 :
			return ("Protocol error");
		break;
		case 72 :
			return ("Multihop attempted");
		break;
		case 73 :
			return ("RFS specific error");
		break;
		case 74 :
			return ("Bad message");
		break;
		case 75 :
			return ("Value too large for defined data type");
		break;
		case 76 :
			return ("Name not unique on network");
		break;
		case 77 :
			return ("File descriptor in bad state");
		break;
		case 78 :
			return ("Remote address changed");
		break;
		case 79 :
			return ("Can not access a needed shared library");
		break;
		case 80 :
			return ("Accessing a corrupted shared library");
		break;
		case 81 :
			return (".lib section in a.out corrupted");
		break;
		case 82 :
			return ("Attempting to link in too many shared libraries");
		break;
		case 83 :
			return ("Cannot exec a shared library directly");
		break;
		case 84 :
			return ("Invalid or incomplete multibyte or wide character");
		break;
		case 85 :
			return ("Interrupted system call should be restarted");
		break;
		case 86 :
			return ("Streams pipe error");
		break;
		case 87 :
			return ("Too many users");
		break;
		case 88 :
			return ("Socket operation on non-socket");
		break;
		case 89 :
			return ("Destination address required");
		break;
		case 90 :
			return ("Message too long");
		break;
		case 91 :
			return ("Protocol wrong type for socket");
		break;
		case 92 :
			return ("Protocol not available");
		break;
		case 93 :
			return ("Protocol not supported");
		break;
		case 94 :
			return ("Socket type not supported");
		break;
		case 95 :
			return ("Operation not supported");
		break;
		case 96 :
			return ("Protocol family not supported");
		break;
		case 97 :
			return ("Address family not supported by protocol");
		break;
		case 98 :
			return ("Address already in use");
		break;
		case 99 :
			return ("Cannot assign requested address");
		break;
		case 100 :
			return ("Network is down");
		break;
		case 101 :
			return ("Network is unreachable");
		break;
		case 102 :
			return ("Network dropped connection on reset");
		break;
		case 103 :
			return ("Software caused connection abort");
		break;
		case 104 :
			return ("Connection reset by peer");
		break;
		case 105 :
			return ("No buffer space available");
		break;
		case 106 :
			return ("Transport endpoint is already connected");
		break;
		case 107 :
			return ("Transport endpoint is not connected");
		break;
		case 108 :
			return ("Cannot send after transport endpoint shutdown");
		break;
		case 109 :
			return ("Too many references: cannot splice");
		break;
		case 110 :
			return ("Connection timed out");
		break;
		case 111 :
			return ("Connection refused");
		break;
		case 112 :
			return ("Host is down");
		break;
		case 113 :
			return ("No route to host");
		break;
		case 114 :
			return ("Operation already in progress");
		break;
		case 115 :
			return ("Operation now in progress");
		break;
		case 116 :
			return ("Stale NFS file handle");
		break;
		case 117 :
			return ("Structure needs cleaning");
		break;
		case 118 :
			return ("Not a XENIX named type file");
		break;
		case 119 :
			return ("No XENIX semaphores available");
		break;
		case 120 :
			return ("Is a named type file");
		break;
		case 121 :
			return ("Remote I/O error");
		break;
		case 122 :
			return ("Disk quota exceeded");
		break;
		case 123 :
			return ("No medium found");
		break;
		case 124 :
			return ("Wrong medium type");
		break;
		case 125 :
			return ("Operation canceled");
		break;
		case 126 :
			return ("Required key not available");
		break;
		case 127 :
			return ("Key has expired");
		break;
		case 128 :
			return ("Key has been revoked");
		break;
		case 129 :
			return ("Key was rejected by service");
		break;
		case 130 :
			return ("Owner died");
		break;
		case 131 :
			return ("State not recoverable");
		break;
		default:
		{
			buf[16] = errcode % 10 + '0';
			buf[15] = (errcode /= 10) % 10 + '0';
			buf[14] = (errcode / 10) % 10 + '0';
			return (buf);
		}
	}
}

char *strerror(int errcode)
{
	return (_Strerror(errcode, NULL));
}

int main(int argc, char const *argv[])
{
	int i;

	for(i=0; i<141; i++)
		printf("%d : %sn",i,strerror(i));	

	return 0;
}

标准库的实现其实只是描述一个大概的形式,自实现这里举了个例子。

c 字符串替换

#include <stdio.h>

/*
字符串替换
char *str_replace(char *dest, char *src, char *replace)
在目标字符串中(dest)查找原字符串(src),如果有找到则替换为replace所指向的字符串。
*/

int mystrlen(char *dest)								//字符长度
{
	int len=0;
	while(*dest++)
		len++;
	return len;
}

char * mystrchr(const char *dest, char search)			
{
	while(*dest != '\0')								//字符查找,字符串不为空字符时,进入循环
	{
		if (*dest == search)							//目标字符如果等于查找字符,则返回指针地址
		{
			return (char *)dest;
		}
		dest++;											//指针自加
	}
	return NULL;
}

int mystrcmp(const char *dest, const char *src)
{
	int result=0;
	while(*src != '\0')
	{
		result = *dest - *src;
		if (result != 0)
		{
			return result;
		}
		dest++;
		src++;
	}
	return result;
}

char * mystrcpy(char *dest, const char *src)
{
	char *start = dest;
	while(*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	return start;
}

char *strend(char *str)
{
	while(*str++)
		;
	str--;
	return str;
}

char *str_replace(char *dest, char *src, char *replace)
{
	int s_flag=1, len_src, len_replace, len_move, n;
	char *p, *start=dest, *end=strend(dest);
	p = mystrchr(dest, *src);

	// 找到相同处
	while(p != end)
	{
		if (p == NULL)
		{
			return NULL;
		}	
		if(mystrcmp(p, src) == 0)
		{// 找到字符串,结束循环
			s_flag = 0;
			break;
		}
		p = mystrchr(p+1, *src);
	}

	// 字符串未找到
	if (s_flag)
	{
		return NULL;
	}
	// 否则找到这个字符串了		

	/*
		移动原本的串
	*/
	// 改变这个串的结构,来适应新替换进来的字符串
	len_src = mystrlen(src);
	len_replace = mystrlen(replace);
	len_move = len_replace - len_src;
	start = p + len_src;

	n = mystrlen( start );

	// 根据len_move的正负来判断往前移动还是往后移动

	if (len_move > 0)
	{
		// 往后移动
		while(n >= 0)
		{
			*( end + len_move ) = *end;					//当目标字符串比替换字符串长时,令整个字符串向后移动字符串位置
			end--;
			n--;
		}
	}else
	{
		// 往前移动
		while(n >= 0)
		{
			*( start + len_move ) = *start;				//当目标字符串比替换字符串短时,令整个字符串向前移动字符串位置
			start++;
			n--;
		}
	}


	// 字符串已移动完毕
	// printf("%sn", dest);

	/*
		将替换字符串拷贝进来
	*/
	mystrcpy(p, replace);

	return dest;
}

int main()
{
	char text[50] = "hi, test is a this.";
	printf("原本的字符串:%sn", text);
	if(str_replace(text, "this", "bug") != NULL)
	{
		printf("字符串替换后:%sn", text);
	}
	else
	{
		printf("字符串替换错误n");
	}
}

排序算法

整理中…

选择排序

#include <stdio.h>
 
void swap(int *a, int *b)
{
  int tmp = *a;
  *a = *b;
  *b = tmp;
}

void sort(int a[], int length)
{
  int i, j;
  int tmp;
  int min;

  for( i = 0; i < length - 1; i ++ )
  {
    min = i;

    for( j = i + 1; j < length; j ++ )
    {
      if(a[min] > a[j])
      {
        min = j;
      }

      if( min != i )
      {
        swap(&a[i], &a[min]);
      }
    }
  }

}
 
int main()
{
  int arr[] = {1, 6, 8, 15, 4, 16, 9, 12};
  int i;

  sort(arr, sizeof(arr)/sizeof(int));

  for(i = 0; i < sizeof(arr)/sizeof(int); i++)
  {
    printf("%d ", arr[i]);
  }

}

冒泡排序

#include <stdio.h>
 
void sort(int arr[], int count)
{
  int temp;
  int i = count;
  int j;      

  while(i > 0)
  {
    for(j = 0; j < i - 1; j++)
    {
      if(arr[j] > arr[j + 1])
      {
        temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
    i--;
  }
}
 
int main()
{
  int arr[] = {1, 6, 8, 15, 4, 16, 9, 12};
  int i;

  sort(arr, sizeof(arr)/sizeof(int));

  for(i = 0; i < sizeof(arr)/sizeof(int); i++)
  {
    printf("%d ", arr[i]);
  }
  
}

地精排序


#include <stdio.h>

void swap(int *a, int *b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void gnome_sort(int arr[], int length) {
	int i = 0;
	while (i < length) {
		if (i == 0 || arr[i-1] <= arr[i])
		{
			i++;
		}else {			
			swap(& arr[i], &arr[i-1]);
		}
	}
}


int main()
{
	int sort[] = { 1, 6, 5, 9, 8, 4 };
	int i;

	gnome_sort(sort, sizeof(sort)/sizeof(int));

	for (i = 0; i < sizeof(sort)/sizeof(int); i++)
	{
		printf("%d ", sort[i]);
	}

	return 0;
}

插入排序

#include <stdio.h>
 
void sort(int arr[], int length)
{
  int i=0,j=0;
  int tmp;

  for(i = 1; i < length; i++)
  {
    j = i;
    tmp = arr[i];

    while(j > 0 && tmp < arr[j-1])
    {
      arr[j] = arr[j-1];
      j--;
    }

    arr[j] = tmp;
  }
}
 
int main()
{
  int arr[] = {1, 6, 8, 15, 4, 16, 9, 12};
  int i;

  sort(arr, sizeof(arr)/sizeof(int));

  for(i = 0; i < sizeof(arr)/sizeof(int); i++)
  {
    printf("%d ", arr[i]);
  }
  getchar();
}