复杂的符号混合（eg:指针数组，数组指针，指针函数，函数指针…）
当各种符号混合在一起，不容易分辨其本质，主要从两方面入手：

1.运算符优先级

2.主要组成部分：

//数组:长度,数据类型

//指针:指向的内容

//函数:参数列表,返回值(C标准规定:函数名本身也表示函数的入口地址)
举例：

①int * p1[10];

优先级：[ ] > * ,因p1与[ ]结合，p1[ ]为数组，p1本质为数组名

p1主要组成部分：长度：10个格子；数据类型：int*（整型指针）

因此p1为保存指针的数组，即指针数组

②int (*p2)[10];

p2与 * 结合 ，本质为指针,

组成部分：指向：数组.

因此p2为指向数组的指针,即数组指针

③int *p3();

p3与（）结合，本质为函数,

组成部分：形参：无 返回值：int *

因此p3为返回指针的函数,即指针函数

④int (*p4)();

p4与 * 结合，本质为指针,

组成：指向：函数.

因此p4为指向函数的指针,即函数指针
扩展：

⑤int *(*p5)();

p5与 * 结合，本质为指针

指针组成：指向：函数

函数组成：形参：无 ；返回值类型：int *（eg：int * p3（）），因此p5本质为指向

形如 int *p3（）的函数的指针，即p5可以保存p3的地址：	p5 = &p3;（p3本质为函数，C标准规定函数名本身也表示函数的入口地址，因此也可写为p5=p3）
⑥int *(*p6)(int,int);

p6与左边最近的 * 结合，本质指针

指针组成：指向：函数（int，int）

函数组成：形参：int，int；返回值类型：int *   （eg：int * p（int，int）），因此p6本质为指向

形如 int *p（int，int）的函数的指针，即p6可以保存p的地址：	p6= &p; （p6=p）

由于项目需要，需要对点、线、面等图形数据进行复杂的符号化展示，自己瞎琢磨了好几天，心态都快不行了的时候，后来才发现只要根据需要重写 draw方法就可以了。
文字符号化
class TextSymbol(geopoint: GeoPoint, text: String, color: Int):  Overlay()  {
    var point = geopoint
    var textStr = text
    var textColor = color
    override fun draw(pCanvas: Canvas?, pMapView: MapView?, p2: Boolean) {
        var localPoint = pMapView!!.projection.toPixels(point, null)
        if (localPoint != null) {
            var paint = Paint()
            paint.style = Paint.Style.STROKE
            paint.color = textColor
            paint.textSize = 32f
            pCanvas!!.drawText(textStr, localPoint.x.toFloat(), localPoint.y.toFloat(), paint)
        }
    }
}

文字符号化弄了个简单的，在使用时传入点，文字以及文字的颜色，添加到地图上即可显示。
点的复杂符号化
class MarkSymbol(geopoint: GeoPoint, pointStyle: Paint,
                 textStyle: Paint, symbol: SimpleFastPointOverlayOptions.Shape,
    circleRadius: Float, vectorDrawableId: Int, context: Context, showLabel: Boolean,text: String,select: Boolean
) : IconOverlay() {
    var point = geopoint
    var textStylePaint = textStyle
    var lable = text
    var pointStylePaint = pointStyle
    var mSymbol = symbol
    var mCircleRadius = circleRadius
    var drawable = vectorDrawableId
    var context = context
    var showLabel = showLabel
    var drawablemIcon: Drawable = context!!.getDrawable(drawable)!!
    var isSelect = select
    init {
        var width = drawablemIcon.intrinsicWidth
        var height = drawablemIcon.intrinsicHeight
        var rect = Rect(0, 0, width + 10, height + 10)
        drawablemIcon.bounds = rect
    }
    override fun draw(pCanvas: Canvas?, pMapView: MapView?, p2: Boolean) {
        var localPoint = pMapView!!.projection.toPixels(point, null)
        if (localPoint != null) {
            drawPointAt(pCanvas!!, localPoint.x.toFloat(),localPoint.y.toFloat(),showLabel, lable,  pointStylePaint,textStylePaint )
        }
    }

    protected fun drawPointAt(
        canvas: Canvas,
        x: Float,
        y: Float,
        showLabel: Boolean,
        label: String?,
        pointStyle: Paint?,
        textStyle: Paint?) {
        if(drawable == null){
            if (mSymbol == SimpleFastPointOverlayOptions.Shape.CIRCLE) {
                canvas.drawCircle(x, y, mCircleRadius, pointStyle!!)
            } else{
                canvas.drawRect(x - mCircleRadius, y - mCircleRadius, x + mCircleRadius, y + mCircleRadius, pointStyle!!)
            }
            if (showLabel && label != null) {
                canvas.drawText(label, x, y - mCircleRadius - 5, textStyle!!)
            }
        }else{
            var bitmap = Command.getBitmap(context!!, drawable)
            var  dst = Rect()
            dst.left = x.toInt()
            dst.top = y.toInt()
            dst.right = x.toInt() + bitmap!!.width;
            dst.bottom = y .toInt() + bitmap!!.height;
            if(!isSelect){
                canvas!!.drawBitmap(bitmap!!,null, dst, null)
            }else{
             var tempBitmap = BitmapUtil().tintBitmap(bitmap, Color.RED)
                canvas.drawBitmap(tempBitmap, null, dst, null)
            }
        }
    }
    var clickListener: OnClickListener? = null
    override fun onSingleTapConfirmed(event: MotionEvent?, mapView: MapView?): Boolean {
        var touched = hitTest(event!!, mapView!!)
        if (touched && clickListener != null) {
            clickListener!!.onClick(point)
            return true
        } else {
            return super.onSingleTapConfirmed(event, mapView)
        }
    }

    fun setOnClickListener(listener: OnClickListener) {
        clickListener = listener
    }
    interface OnClickListener {
        fun onClick(point: GeoPoint?)
    }
//判断是否点中了点
    protected fun hitTest(
        event: MotionEvent, mapView: MapView): Boolean {
        var pj = mapView.projection
        if (point == null || mPositionPixels == null || pj == null) return false
        pj.toPixels(point, mPositionPixels)
        var screenRect = pj.intrinsicScreenRect
        var x = -mPositionPixels.x + screenRect.left + event.x.toInt()
        var y = -mPositionPixels.y + screenRect.top + event.y.toInt()
        return drawablemIcon.bounds.contains(x, y)
    }
}

这个复杂一点，包括想将点展示成图片，点的选中状态等等。如果是选中状态的话将颜色改变成红色，进行区别展示。

测试环境：windows10

声明：因为特殊字符产生的缺字符和长度错误已修正

使用方法：

1.第一段代码：

文本编辑器如editplus，保存，保存类型选择“所有文件”，名称为“密码.bat”

可以修改密码长度，大小写字母数字符号的数量，对应第二段代码TXT文件中大小写字母数字符号的数量

2.第二段代码：

文本编辑器如editplus，保存，保存类型选择“所有文件”，名称为”zdb.txt"，内容可根据需要修改

3.第一段和第二段代码放到同一目录

4.原始密钥是按照大写字母，数字，小写字母，符号为一组生成的，乱序密钥是原始密码的乱序排列，

最终密码就是乱序密码，可以用于乱序，也可以用于复杂的乱序密钥的生成

5.代码涉及变量嵌套和延迟的语法，可以作为相关应用的参考

6.如果原始密钥写固定值，可以书写如下call set "key=XXXXXX"，并保留len这个变量及固定值长度，注意固定值中的特殊字符要转义，加^

7.改了一处错误

密码.bat代码:

@echo off
setlocal enabledelayedexpansion
rem 密钥长度
set len=32
rem 大写字母数量
set caplen=25
rem 数字数量
set numlen=10
rem 小写字母数量
set noncaplen=24
rem 符号数量
set signlen=8
set key=
for /L %%i in (1,1,!len!) do (
set /a dig=%%i%%4
if !dig! EQU 1 (
set /a n1=!random!%%!caplen!
set idx1=0
for /L %%a in (1,1,!caplen!) do (
if !n1! EQU !idx1! (
set /a num=%%a
)
set /a idx1+=1
)
)
if !dig! EQU 2 (
set /a n2=!random!%%!numlen!
set idx2=0
set /a minnum=!caplen!+1
set /a maxnum=!minnum!+!numlen!-1
for /L %%b in (!minnum!,1,!maxnum!) do (
if !n2! EQU !idx2! (
set /a num=%%b
)
set /a idx2+=1
)
)
if !dig! EQU 3 (
set /a n3=!random!%%!noncaplen!
set idx3=0
set /a minnoncap=!maxnum!+1
set /a maxnoncap=!minnoncap!+!noncaplen!-1
for /L %%c in (!minnoncap!,1,!maxnoncap!) do (
if !n3! EQU !idx3! (
set /a num=%%c
)
set /a idx3+=1
)
)
if !dig! EQU 0 (
set /a n4=!random!%%!signlen!
set idx4=0
set /a minsign=!maxnoncap!+1
set /a maxsign=!minsign!+!signlen!-1
for /L %%d in (!minsign!,1,!maxsign!) do (
if !n4! EQU !idx4! (
set /a num=%%d
)
set /a idx4+=1
)
)
set idx=1
for /F %%j in (zdb.txt) do (
if !num! EQU !idx! (
set key=!key!%%j
)
set /a idx+=1
)
)
echo 原始密钥是!key!
echo.
set key1=
for /L %%z in (!len!,-1,1) do (
rem 取随机索引
set /a idx=%random%%%%%z
rem 下一个索引
set /a idx1=!idx!+1
call call set "o=%%%%key:~%%idx%%,1%%%%"
if !idx! equ 0 (
call call set "key=%%%%key:~%%idx1%%%%%%"
) else (
set /a maxidx=%%z-1
if !idx! geq !maxidx! (
set idx=!maxidx!
call call set "key=%%%%key:~0,%%idx%%%%%%"
) else (
call call set "key=%%%%key:~0,%%idx%%%%%%%%%%key:~%%idx1%%%%%%"
)
)
set key1=!key1!!o!
)
echo 乱序密钥是!key1!
echo.
echo 最终密钥是!key1!
echo.
pause
exit

zdb.txt代码:

A
B
C
D
E
F
G
H
I
J
K
L
M
N
P
Q
R
S
T
U
V
W
X
Y
Z
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
g
h
i
j
k
m
n
p
q
r
s
t
u
v
w
x
y
z
^~
^!
^@
^#
^$
^%
^^
^&

（全文完）

 

在unix和vim方面，文本处理能力最强的手段就是正则表达式了，但是这也恰恰是比较难记忆的。最痛苦的莫过于复杂的表达式，丑陋的字符转义。


下面就讨论如何记忆字符转义的情形。

首先字符转义无非就分两种：

1：将普通字符转义为屏幕上无法表示的特殊字符，典型的就是c语言中的转义。\n,\r,\b之类。

2：将具有特殊意义的字符转换为原本普通的意义。比如正则表达式中的 . * ( ) [

]  之类的。


当一个字符在哪种情况下使用的多，那么它单独出现时就表示那种使用的多的意义，而不常用的意义需要表达时，则通过转义来实现。比如正则表达式中，“."和”*“，还有其它的所有特殊字符，特殊意义都是常用的，那么通常情况下单独出现时，就取它的特殊意义。而当需要使用 * 的字面意义时，就用\*来表示。


这样的话

1：正则表达式中有两种字符，一种就是普通的，一种就是特殊的。当他们没有被转义时普通的就表示普通的，特殊的就是特殊的。

2:我们现在只需要记住特殊的字符什么时候会被转义为原本的字面意义。

3：当使用转义符号"\"时，特殊字符无疑会被转义为原本的意义。

4：有些特殊字符是位置相关的，比如^,$,-。"^"位于行首时就是特殊的，不是行首时就是字面意义的。"$"位于行尾时，就是特殊的，当位于非行尾时就是字面意义的。当"-"位于[]中时，比如[a-z]，这时候就是特殊的，当不位于[]中时，就是普通的。

任何特殊符号在[]中都是字面意义的，不需要被转义，但是\,-,]除外，这三种在[]中表示字面意义时，需要转义。






这里有个需要注意的地方：grep 的历史上，刚发展出来时，只提供了基本的元字符，比如"*",".","[","]","*"等运算符，后来因为不能满足某些人的需求，这些人自己对元字符做了扩展，增强了正则表达式的能力，这也就是egrep了——而扩展的元字符分别有“(",")","?","+"等。
所以后来grep 为了支持这些扩展的元字符，又保持与自己历史版本的兼容，所以在grep中可以使用“\"后面跟扩展扩展元字符表示元字符的意义。
而在egrep中扩展的元字符本身就是元字符意义，而如果使用扩展的元字符的字面意义，则需要使用转义符号”\"。
从grep 和 egrep对于扩展的元字符的不同解释中，也可以看出转义符作用：要不就是字面转特殊，要不就是特殊转字面！！！
但是egrep 中这种统一的风格更让人容易接受，元字符就是元字符，元字符转义才是字面意义。不像grep中有些字符是元字符，有些字符则代表字面意义（需要转义才行）。


可能grep 也觉得自己这样子不好，所以提供了-E选项，这样的话，grep -E 和 egrep 的行为模式就基本想通了。我一般用grep -E 和 egrep的。