Oct 19

对照一下两段代码 不指定

felix021 @ 2009-10-19 00:22 [IT » 程序设计] 评论(6) , 引用(0) , 阅读(6141) | Via 本站原创
    unsigned int a = 1;
    int b = 0;
    while (a + b >= 0) {
        b--;
    }


#gcc -S a.c -o a.S
然后看到对应这些代码

    movl  $1, -4(%ebp)
    movl  $0, -8(%ebp)
L2:
    movl  -4(%ebp), %eax
    leal  -8(%ebp), %eax
    decl  (%eax)
    jmp  L2


阿牛如果有兴致的话，不妨研究一下AT&T的汇编。
Sep 15

PHP 递归处理文件 不指定

felix021 @ 2009-9-15 12:34 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(3772) | Via 本站原创
突然发现这代码我写过n遍了，真不爽。。。

<?php

$dirname = "ooxx";
$pattern = 'google';
$replace = 'baidu';
$DontReplace = true;

replace_rec($dirname);

function replace_rec($dirname, $layer = 0){
    global $DontReplace;
    static $cnt = 0;
    $dir = scandir($dirname);
    natcasesort($dir);
    foreach($dir as $item){
        if($item == '.' || $item == '..') continue;
        $path = "$dirname/$item";
        if(is_dir($path)){
            replace_rec($path, $layer+1);
        }else if(is_file($path)){
            $str = file_get_contents($path);
            if(strpos($str, $pattern) === false) continue;
            if($DontReplace == false){
                $str = str_replace($pattern, $replace, $str);
                file_put_contents($path, $str);
            }  
            $cnt++;
            for($i = 0; $i < $layer; $i++) echo '  '; echo "$cnt: $path\n";
        }else{
            echo "UNKNOWN TYPE\n";
        }  
    }  
}
?>
Aug 17

关于delete 不指定

felix021 @ 2009-8-17 15:07 [IT » 程序设计] 评论(4) , 引用(0) , 阅读(6336) | Via 本站原创
前两天在Dutor(或者是Ivan?)的Blog看到了一篇文章：
关于free和delete http://www.dutor.net/index.php/2009/08/free-delete/

以前没有仔细考虑过这个问题，因此和Sandy讨论了一下，得出了初步结果，总结一下放在这里吧。

---传说中的分割线---

先看一段代码:
#include<iostream>
class T{
public:
    int *a;
    T() {
        a = new int[1048576];
        std::cout << "T()" << endl;
    }
    ~T() {
        delete[] a;
        std::cout << "~T()" << endl;
    }
};

int main() {
    T *a = new T;
    delete (char*)a;
}

这段代码的前面还是比较好理解的，关键在于，这最后的 delete (char *)a; 它究竟做了什么事情？
1. 它释放了多少内存——是释放了一个char*指向的内存，还是当初new分配的那些内存？
2. 它是否调用了class T的析构函数？

下面是我和Sandy的讨论结果，针对以上两个问题的分析，以及一点延伸的探讨。

1. 释放了多少内存。
回头想想C提供的malloc/free函数，这小俩口处理的都是void*类型的指针，而且当free时只要告诉其指针即可。
也就是说，malloc函数多做了一些事情，让程序在某处记住了分配的内存大小，当free时，对应找到这个大小进行释放。
因此我们有理由认为，new/delete这对黑白脸做法也是类似的（没有小心求证，如果不对，请大牛指出）：
-- new从堆上申请内存，是先进行记录，包括新内存的地址以及申请的长度，然后才把地址返回给申请者。
-- delete根据释放者提交的地址，在记录中查找这个地址，然后找到其长度，然后回收内存。。
故此我们认为，它释放的内存是new分配的那些内存，与传入的指针类型无关。

2. 是否调用了相应的析构函数。
这个问题很容易验证，把上面的程序跑一遍就可以了。
结果就是，输出了 "T()" 这一行，说明只调用了构造函数而没有调用析构函数。
仔细想想，其实这很容易理解。
隐约记得STL之父(Or C++之父?)说过一句话，你有很多事情做，但是编译器没有。
C++编译器被设计成帮你完成了很多琐碎的事情，很典型的一件事就是，编译期类型推导。
因此你在cout的时候也不需要指定输出类型(%d%x%c...)
new一个东西以后不需要像malloc那样进行强制类型转换了，还自动调用class 的构造函数，
delete一个指向class的指针时，也根据指针的类型自动添加了调用该class析构函数的代码。
而上面给出的代码，最终交给delete的是一个char *类型的指针
因此编译器添加的代码就不会涉及到class T的析构函数。
如果你是转换成另一个class Q的指针，那么就会调用Q的析构函数。有兴趣的话可以自己写程序证实一下。

3. 它会导致严重的后果吗？
答案是会。
比如上面给出的程序，造成了内存泄漏：预期在析构函数中释放的 T::a 指向的内存，但是析构函数最终没有被执行。

4. 它会导致更严重的后果吗？
答案还是会。
这一点是Sandy提出来的：在C++中，operator new/delete是可以被重载的。
如果一个class的operator new/delete被重载了，它将以它自己的方式去管理(分配/回收)内存。
比如说以内存池的方式；或者是在栈上进行分配的内存。
如果你使用这种方式去delete一个改变了类型的指针，那么结果就是，采用了不同的管理方式去回收这个内存。
——就好比你malloc出来的内存被delete掉了
传说中的换妻啊。。。后果就是对方崩溃了。。。嗯。

--------传说中的分割线--------

这个问题到这里差不多了，实际使用中应该不会有谁这么脑残的吧，嗯。
进行这样的一些分析，主要是希望能够更深入地理解C++这一块的内容。

还没有确切解决的疑问就是第一个——
new/delete 释放的内存块大小是否关乎指针类型？希望有大牛释疑。

另外顺便提一下，我觉得当在C++中需要使用对class进行强制类型转换的时候，
应该好好考虑一下，这程序是不是在设计上出了什么问题，因为这么做会增加程序的耦合性。
当然，在某些时候你的确会需要用到这种做法，因为这样可以增加程序的动态性（许多Java程序依赖于此）。
Jul 26

短信大师导出短信为txt后的一个php整理程序 不指定

felix021 @ 2009-7-26 16:37 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(4371) | Via 本站原创
1. 选中收件箱和发件箱


2. 菜单->操作->导出文本


3. 把导出的短信都放在一个目录下面


4. 在目录下放一个convertencoding.php，内容为：
<?php
$dir = scandir(".");
foreach($dir as $file){
    if(substr($file, -3) != "txt") continue;
    echo $file, "\n";
    $str = file_get_contents($file);
    $str = iconv("GB18030", "UTF-8", $str);
    file_put_contents($file, $str);
}
?>
然后$ php convertencoding.php 运行之。


5. 另一个php脚本，用于提取和指定的人的聊天记录
Jul 26

php数组按键排序 不指定

felix021 @ 2009-7-26 15:47 [IT » 程序设计] 评论(2) , 引用(0) , 阅读(7331) | Via 本站原创
遇到一个问题：
有一个数组，其中每个元素都包含time和content两个子元素，需要按time字段排序。

记得以前是搞过这个东西的，有个专门的函数，貌似就是array_multisort来搞。
查了一下mannual，发现例子实在太晦涩，看起来很不爽。
于是干脆自己实现一个，只需要提供一个排序函数即可。
效率可能低一些，但是用起来舒服多了。。

//调用例子(cmp函数可以自己重写):
mysort($array_name, 0, count($array_name) - 1, cmp);

function cmp($i, $j){
    return $i['time'] < $j['time'];
}

function mysort(&$arr, $s, $e, $func){
    $i = $s; $j = $e; $tmp = $arr[$s];
    if($s < $e){
        while($i != $j){
            while($i < $j && $func($tmp, $arr[$j])) $j--;
            if($i < $j){
                $arr[$i] = $arr[$j];
                $i++;
            }
            while($i < $j && $func($arr[$i], $tmp)) $i++;
            if($i < $j){
                $arr[$j] = $arr[$i];
                $j--;
            }
        }
        $arr[$i] = $tmp;
        mysort($arr, $s, $i-1, $func);
        mysort($arr, $i+1, $e, $func);
    }
}
Jul 8

ooxx的const 不指定

felix021 @ 2009-7-8 00:13 [IT » 程序设计] 评论(3) , 引用(0) , 阅读(6808) | Via 本站原创
咱们来对比一下这5个东西：
char ** a;
const char ** b;
char * const * c;
const char * const * d;
const char * const * const e;

——天哪，这都是什么东西？用5个小程序来解释一下。。或许你可以看得懂？
如果你急着和mm去约会，直接跳到文末，有比较简洁的说明。

#include <iostream>
#include <cstring>
using namespace std;

void test1(){
    char **s; //s是数组的指针;
    s = NULL;
    s = new char*[4];
    for (int i = 0; i < 4; ++i){
        s[i] = new char[10];
        strcpy(s[i], "test");
    }
    for (int i = 0; i < 4; ++i){
        printf("%s\n", s[i]);
    }
    for (int i = 0; i < 4; ++i){
        delete[] s[i];
    }
    delete[] s;
}

void test2(){
    const char **s; //s是指向字符串常量的指针
    s = NULL;
    char b[4][10] = {"a","b","c","d"};
    s = new const char*[4];
    for (int i = 0; i < 4; ++i){
        s[i] = b[i]; // OK
        //s[i][0] = 'd'; //这句要报错,因为s[i]指向的是字符串常量
                    //即使b[i]字符串本不是常量(编译期间添加的属性)
    }
    for (int i = 0; i < 4; ++i){
        printf("%s\n", s[i]);
    }
    delete[] s;
}

void test3(){
    char * const * s; //s指向常量数组，数组的每一个元素是字符指针常量。
                //数组的元素不可改，但数组元素指向的字符串可修改    
    s = NULL;// s不是常量
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
    for (int i = 0; i < 4; ++i){
        s[i][1] = 'd'; //OK
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}

void test4(){
    const char * const * s; //s指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(绕口令阿这是。。。)
    s = NULL;// s不是常量
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
    for (int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}

void test5(){
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    const char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    const char * const * const s = b;
    //s是一个常量指针，指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(这才是绕口令！)
    //s = NULL; //Error, s是常量
    for (int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}

int main(){
    test5();
    return 0;
}


OK，其实有一种很简单的阅读方法：从右向左读定义，结果就是——
char ** s;
s是一个指针1，指向一个指针2, 指针2指向char

const char ** s;
s是一个指针1，指向一个指针2，指针2指向char，char是常数

char * const * s;
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char

const char * const * s;
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char，char是常数

const char * const * const s;
s是一个常量1，常量1是一个指针1，指针1指向一个常量2，常量2是个指针2，指针2指向char，char是常数
Jun 23

采用败者树(?)的多路归并 不指定

felix021 @ 2009-6-23 10:15 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(5308) | Via 本站原创
坦白说，我不确定这个东西是不是叫做败者树，因为我觉得它就是以前写过n遍的线段树的一个简单变种。
在线段树的每个节点存储v, i，分别表示该区间内最小值和最小值所在单元的索引。
建立好线段树以后，每次取出整个区间的最小值，然后将该值来源的那一路的下一个数字填充进去
如果那一路已经没有下一个数字了，就填一个max进去，然后递归地更新其所有祖先节点。
这个过程有点像heap的sift_up。

代码如下:
Jun 23

采用堆的多路归并 不指定

felix021 @ 2009-6-23 00:38 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(4410) | Via 本站原创
一般数据结构上用败者树来实现，这东西我没写过，所以暂时忽略之。
改用相对比较熟悉的heap来处理，写了一个class heap。
为了方便采用一个 5 x 5 的数组来存储需要归并的数据；很容易可以扩展到不定长的不同数据组。
明天再试着写一下败者树。

代码如下：
分页： 11/23 第一页 上页 6 7 8 9 10 11 12 13 14 15 下页 最后页 [ 显示模式： 摘要 | 列表 ]