学步园

转载自：http://blog.sina.com.cn/s/blog_3e38d2cb0100beo0.html

1、加载图片后并不能立即对加载的图片进行操作，必须注册一个侦听器。

   var picLoader:Loader=new Loader();

picLoader.load(new URLRequest("pic.jpg"));
 picLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,picLoad);

function picLoad(e:Event) {

 trace(picLoader.width)}

2、显示对象没有添加到舞台前，是不能对舞台stage注册侦听的。

  如：stage.addEventListener(KeyboardEvent.KEY_DOWN,keyDownEvent);这是会报错的；

应改为 mainTimeline.stage.addEventListener(KeyboardEvent.KEY_DOWN,keyDownEvent);

把主时间轴加上才可以。或者先注册如下的侦听事件也是可以的：

addEventListener(Event.ADDED_TO_STAGE,init);
   function init(e:Event) {
    stage.addEventListener(KeyboardEvent.KEY_DOWN,keyDownEvent);
    stage.addEventListener(KeyboardEvent.KEY_UP,keyUpEvent);
   }

这样似乎更好理解。

3、使用Timer类一张张加载多张图片时，每次都需要申明一个loader类对象；

var picCount:uint=0;

var picTimer:Timer=new Timer(1000);
picTimer.start();
picTimer.addEventListener(TimerEvent.TIMER,timerHandler);
function timerHandler(e:TimerEvent):void {
 var picLoader:Loader=new Loader();//每次加载一张图片后，都需要申明loader对象；
 picCount++;
 picLoader.load(new URLRequest("pic"+picCount+".jpg"));
 picLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,picLoad);
 if (picCount>=7) {
  picTimer.stop();

 }
}
4、在写as外部类文件时，多个类间的沟通和联系是个难点。通常是通过传递参数实现类之间的交互的；

以上仅仅是我学习的一点体会，不对之处，敬请各位老师批评指正。

字节数组和十六进制字符串的互转

/**
 * 这个函数最大的问题，就是用了很多 if 判断语句，
 * 运气不好的时候（执行到最后一行 return 0; 的时候），要比较 6 次，跳转 3次
 * (每次 if 里的条件不成立，程序就要跳转的。当然是要去看汇编，里面才有跳转指令)
 * switch 就更慢了，每个 case 都要比较一次。
 * 其实有更简单、更快的算法 —— 用数组！
 * 这叫 “查表法”，缺点就是空间消耗比较大。
 * 定义一个有 256 个元素的数组，都不用写这个函数了，直接调用数组即可，函数里直接返回，还有调用函数的开销呢。
 */
int hex2int(char in_oChar) {
    if (in_oChar >= '0' && in_oChar <= '9') {
        return (in_oChar - '0');
    }
    if (in_oChar >= 'A' && in_oChar <= 'F') {
        return (in_oChar - 'A' + 10);
    }
    if (in_oChar >= 'a' && in_oChar <= 'f') {
        return (in_oChar - 'a' + 10);
    }
    return 0;
}

/**
 * 用查表法，<< 4 也可以省掉，不过要用 2 个数组了
 * in_oStrHex.at(i) 有一定的开销，建议不要用 stirng 传输入进来，传个指针（const char*）就够了
 * 对大于 0 的整数，不要 /2 ，要 >>1
 * 一个函数调用的开销有多大？如果不是 inline 的函数，开销和函数体内的运算比，就比较大了
 */
int hexs2bts(std::string in_oStrHex, bt* out_pArrBt) {
    int t_iSize = (int)in_oStrHex.length();
    out_pArrBt = new bt[t_iSize / 2];
    for (int i = 0; i < t_iSize; i += 2) {
        out_pArrBt[i / 2] = (hex2int(in_oStrHex.at(i)) << 4) | hex2int(in_oStrHex.at(i + 1));
    }
    return t_iSize / 2;
}

/**
 * “耗费空间比较大” 的话，我感觉 256 不是很大啊，毕竟是 bt 而已
 * 要想运算快的话，就要用 int 数组!
 * 这里有个字节对齐的问题，字节对齐的话，访问速度快，字节没对齐，指针要调整 2 次。
 * 这个是操作系统的原理，“字节对齐” 这个概念对各种操作系统都适用。
 */
const int g_oArrIntTable[256] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
    13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0,
};


/**
 * 上述函数改进后的写法
 * 这里直接传 out_pArrbts 指针进来，内存分配在调用该方法之前就弄好（因为长度是已知的）
 * in_iLen 是 out_pArrbts 数组的长度；
 * (in_iLen * 2) 是十六进制字符串的长度。
 * 使用 new 的时候一定要防止失败时出现异常
 * 用 new 的话，一定要放在 try{} catch{} 里，内存不够或者内存碎片过多没有连续内存分配的时候就会出错，
 * 软件写得不好，长时间运行就有可能出现这种情况。出现异常，没有处理代码的话，软件马上就崩溃了
 * 我们用 new<nothrow> , 分配后检查指针是否为 NULL。new 有 4 种用法，网上有相关资料。
 */
void hexs2bts(bt* out_pArrBts, int in_iLen, const char* in_pArrHex) {
    if (!out_pArrBts) {
        printf("NULL == out_pArrbts\n");
        return;
    }
    for (int i = 0; i < in_iLen << 1; i += 2) {
        char tmp_c0 = *(in_pArrHex + i);
        char tmp_c1 = *(in_pArrHex + i + 1);
        out_pArrBts[i >> 1] = (g_oArrIntTable[tmp_c0] << 4) | g_oArrIntTable[tmp_c1];
    }
}

const char* const strHEX_ITEMS =  "0123456789ABCDEF";

/**
 * 这个函数返回一个栈对象，没啥问题，就是效率低了点
 * t_oStrHex 在函数结束的时候要析构销毁，重新产生一个临时对象返回
 * 所以这个函数最好增加一个输出的形参，可以用指针。
 * string t_oStrHex; 要执行一个构造函数
 * return t_oStrHex; 要执行一次析构函数，一次构造函数产生临时对象，赋值后临时对象再执行一次析构函数。
 * strHexItems 这个 string 也是没必要使用的，这些底层函数，可以全部用指针操作的，没必要用 string（注意指针别越界）
 */
string bts2hexs(bt* in_pArrBts, int in_iLen) {
    string t_oStrHex;
    string strHexItems(strHEX_ITEMS);
    for (int i = 0; i < in_iLen; i ++) {
        t_oStrHex.append(1, strHexItems.at(0x0f & (in_pArrBts[i] >> 4)));
        t_oStrHex.append(1, strHexItems.at(0x0f & in_pArrBts[i]));
    }
    return t_oStrHex;
}

/**
 * 改良后的函数
 */
const int g_oArrIntHex[16] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
void bts2hexs(string& out_oStrHex, bt* in_pArrBts, int in_iLen) {
    if (!in_pArrBts) {
        printf("NULL == in_pArrbts\n");
        return;
    }
    for (int i = 0; i < in_iLen; i ++) {
        out_oStrHex.append(1, g_oArrIntHex[0x0f & (in_pArrBts[i] >> 4)]);
        out_oStrHex.append(1, g_oArrIntHex[0x0f & in_pArrBts[i]]);
    }
}