f(Program,Poet)=Programet » 程序 http://blog.programet.org f(诗,程序)=诗序=思绪 | 记载我们自己的生活 Tue, 07 Feb 2012 16:00:20 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Haskell随手笔记：infinite list http://blog.programet.org/2011/12/haskell%e9%9a%8f%e6%89%8b%e7%ac%94%e8%ae%b0%ef%bc%9ainfinite-list.html http://blog.programet.org/2011/12/haskell%e9%9a%8f%e6%89%8b%e7%ac%94%e8%ae%b0%ef%bc%9ainfinite-list.html#comments Tue, 06 Dec 2011 17:01:21 +0000 严酷的魔王 http://blog.programet.org/?p=4818
  • 让我们比比长短
  • 寻找满分单词
  • 晒：C语言期中实验报告
    • ]]>     为了与寺雷颠保持一致，这是一个不知道什么时候就会太监的系列。——题记

    其实这一切的开端都是Mgccl大牛作祟。在他的各种代码影响下，我就萌生了接触一点函数式编程的念头。其实还有一个原因便是我现在经常使用R语言做统计作业，但是R语言实际上是S语言的继承。本来S语言是一个函数式编程的语言，但是R这么一继承就变得有些不伦不类的……所以我也怀着“了解了函数式编程就能更好地学会R了吧！！”的情绪。最后，Haskell这个名字依然在三年前的《让我们比比长短》一文中出现了，这里函数式编程给我留下了各种深刻的印象。

    Haskell有两本可以在线看的教材：《Real World Haskell》和《Learn You a Haskell》两本。它们应该算是基础教材了吧，也就是让你能够初步接触Haskell。然后还有一个介绍内置函数的pdf。

    我用的是WindowsXP（你们不要斜眼看过来！），于是首先去Haskell的官网下载了GHC(应该算是一个运行环境？命令行式的)。然后它会自动修改你的环境变量，于是新建一个后缀名为.hs的文件便会自动调用GHC载入代码。

    ——————胡言乱语的分割线——————

    Haskell里面没有循环，但是我们可以用递归来实现它。比如下面这段计算斐波那契数列的C代码：

    f[0]=1;
f[1]=1;
for (i=2;i<n;i++)
	f[i]=f[i-1]+f[i-2];

    可以在haskell里面用递归的形式这样写：

    fib n = lst 1 1 n 
	where lst a b c = if c<2 then a 
				 else lst (a+b) a (c-1)

    但是鉴于Mgccl大牛对elegance的追求，以及haskell一个很神奇的特质，我们可以用”infinite list”来一句话实现这个操作：

    fib n = fibs !! n
        where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

    haskell有一个lazy的特点，也就是所有的东西都会在需要的时候才去计算。haskell内置了一个函数repeat n，就是生成一个长度无限的list[n,n,n,n,… 。这种涉及无穷的东西并不会瞬间吃光你的内存，而是在你需要算到第n个数时，它才会帮你算到那个数。因为这个特点，在haskell中实现循环还有另一种方法：事先找到这个循环的规律，然后类似通项公式一般地生成一个无穷表，然后这个list的第n项就是循环到n的结果。

    另一个例子，解决的问题是ProjectEuler第97题。我的代码是：

    powMod2 n = l 1 n 2 where
            l i n ans = if (i*2<=n) then l (i*2) n (mod (ans^2) (10^10))
			            else if ((i<n) && (i*2>n)) then mod (ans*(l 1 (n-i) 2)) (10^10)
						else ans
ans_97 = mod (28433*(powMod2 7830457)+1) (10^10)

    仍然保留在简单粗暴的递归式循环上。而Mgccl大牛的代码则如下：

    bin 0 xs = xs
bin n xs = bin q (r:xs)
        where (q,r) = divMod n 2
result = (t*28433+1) `mod` m
  where t = foldr (mmod) 1 $ filter (/=0) (zipWith (*) (reverse $ bin 7830457 []) twoPow)
        twoPow = 2:zipWith mmod twoPow twoPow
        m = 10^10
        mmod a b = mod (a*b) m

    不得不说神牛的版本在很大程度上增强了代码的可读性。
    这个就是利用haskell的infinite list属性来简化代码的很好的例子，但是不得不说在还没习惯这种思维的时候这对我来说是一种很强烈的脑力锻炼。

    目前来说，感觉haskell在对付ProjectEuler的内容上比C什么的简洁太多了，而且高精度这个我很讨厌的东西也算是不用再考虑了。最近忙生物统计去了，haskell练习也被我放下了一段时间，不过鉴于下学期我只有三门课一周10节的节奏，兴许会有比较多的进步什么的。

    本文由 严酷的魔王 创作，转载或引用前请联系我们。

    相关文章：

    1. 让我们比比长短
    2. 寻找满分单词
    3. 晒：C语言期中实验报告

    ]]>     http://blog.programet.org/2011/12/haskell%e9%9a%8f%e6%89%8b%e7%ac%94%e8%ae%b0%ef%bc%9ainfinite-list.html/feed 6     纪念；里奇 http://blog.programet.org/2011/12/%e7%ba%aa%e5%bf%b5%ef%bc%9b%e9%87%8c%e5%a5%87.html http://blog.programet.org/2011/12/%e7%ba%aa%e5%bf%b5%ef%bc%9b%e9%87%8c%e5%a5%87.html#comments Thu, 01 Dec 2011 13:08:30 +0000 最后的叶子 http://blog.programet.org/?p=4801
  • 让我们比比长短
  • NOIP实用算法 7.分治
  • 晒：C语言期中实验报告
    • ]]>     有时，我写着一行行分号结尾的句子，中途还忍不住停下。

    想想，已经过去将近两个月了吧。

    C语言发明人，UNIX的父亲之一，不知道这两个身份是否过于沉重。想想，也是可以离去的时候了吧。

    天堂这一个多月过得还好吧？Dennis，你知道还有多少世界各地的人们在怀念你吗？

    “计算机程序的灵魂造型师”。Dennis，这样称呼你可以吗？

    至于那些天天念叨着某不死的成功学家们，忽略他们吧。伟大的事物，大多难以被多数人关注，尽管与他们形影不离。

    只是，在网上看到的那句话总显得有些酸涩：“可惜他不是商人，没有得到更多人的膜拜。”

    也许，这个时代为了某个小小的追求，已经抛弃了太多太多宝贵的东西……

    也请，不要在意。那些小小的分号，是你在这个世界上无法抹去的剪影。

    没什么可遗憾的了。Dennis Ritchie的印记，已经铺遍世界。

    你也能看到吧……能听到吧……

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. 让我们比比长短
    2. NOIP实用算法 7.分治
    3. 晒：C语言期中实验报告

    ]]>     http://blog.programet.org/2011/12/%e7%ba%aa%e5%bf%b5%ef%bc%9b%e9%87%8c%e5%a5%87.html/feed 0     “你们的hello world 都弱暴了 ” http://blog.programet.org/2011/08/%e2%80%9c%e4%bd%a0%e4%bb%ac%e7%9a%84hello-world-%e9%83%bd%e5%bc%b1%e6%9a%b4%e4%ba%86-%e2%80%9d.html http://blog.programet.org/2011/08/%e2%80%9c%e4%bd%a0%e4%bb%ac%e7%9a%84hello-world-%e9%83%bd%e5%bc%b1%e6%9a%b4%e4%ba%86-%e2%80%9d.html#comments Wed, 31 Aug 2011 12:34:44 +0000 严酷的魔王 http://blog.programet.org/?p=4546
  • 学习使用GTK+ 2.GTK+“Hello World”——对GTK+运作机制的通俗介绍
  • 说什么就是什么：Your World Of Text
  • Half a World Away
    • ]]>     ——标题来自于果壳网烧饭阿姨的帖子。

    阿姨的帖子只有下面这幅图(请点击查看大图)：

    图片有点大(4.2M)，小水管用户请耐心等待。

    这幅图展示的内容看起来非常神奇，一个人用windows的画板便能够code出一个hello world出来。当然电脑上面的任何看似神奇的东西一定是有其原理的。所以我觉得自己也能够制造出同样的效果。

    为了还原这段代码对应的bmp图像，我在经过各种尝试之后觉得下面这种方法应该是最简单的了。

    首先我们需要一个16位编辑器来进行主要操作，像什么UltraEdit，WinHex就很好了，我在网上找到的是一个只有80K大小的Hex-Ed。

    然后我们新建一个txt文件，在里面输入你的代码，就比如图片中的

    #include

    int main()

    {

    std::cout<<”Hello World”<

    return 0;

    }

    输入之后，保存。接着我们用Hex-Ed打开刚才编辑的这段代码，你就应该看到如下画面：

    保留着这个窗口，不要关闭。接着我们新建一个bmp文件，保留内容的空白，使用windows自带画图将大小调整为8*4的规格并保存图片——如果觉得自己鼠标不够稳，不妨在8倍放大的模式下进行尺寸调整。再次使用Hex-Ed打开这个bmp文件，你看到的内容应该如下所示：

    那一串串的“FF”实际上就是bmp图像中白色色块的代码。接下来我们要做的就是用第一幅图中代码的内容覆盖掉所有的”FF”。在输入代码的时候，文字可以直接在右边的窗口输入，但是不可见字符（比如换行符制表符之类的）就可以在左边输入16进制的数字代码。对照着编辑完之后，我觉得你应该会看见下面的效果：

    将这个编辑成果保存之后，打开那个bmp图，放大了仔细看——是不是出现了五颜六色的色块了？与动态图中一样，用记事本打开，应该也出现了同样的代码~

    最后，大家可以从这幅色彩斑斓的图片中提取出颜色信息，努力背诵，说不定可以在初级程序员面前直接用画图作画，像动态图中的那样大显身手哦~至于灵活运用于向GEEK妹子表白之类的用途我才不会说呢……

    本文由 严酷的魔王 创作，转载或引用前请联系我们。

    相关文章：

    1. 学习使用GTK+ 2.GTK+“Hello World”——对GTK+运作机制的通俗介绍
    2. 说什么就是什么：Your World Of Text
    3. Half a World Away

    ]]>     http://blog.programet.org/2011/08/%e2%80%9c%e4%bd%a0%e4%bb%ac%e7%9a%84hello-world-%e9%83%bd%e5%bc%b1%e6%9a%b4%e4%ba%86-%e2%80%9d.html/feed 2     让WordPress保留段首空格的插件 http://blog.programet.org/2011/04/keep-blanks.html http://blog.programet.org/2011/04/keep-blanks.html#comments Fri, 29 Apr 2011 08:47:52 +0000 最后的叶子 http://blog.programet.org/?p=4197
  • 沉迷
  • 问问matlab:WHY?
  • NOIP实用算法 1.模拟方法
    • ]]>     叶子前段时间为制作网站苦心研究Wordpress，博客更新少了一点，先道歉。不过还是有可以拿来和大家分享的成果滴~~

    其一便是终于搞定了Wordpress自动去除段首空格的问题！

    去各种狗了一下“让Wordpress保留段首空格的方法”，发现能搜到的最好的解决方案是，在主题css中使用text-indent来让每个段落段首自动缩进两字符（其实这也是Programet目前使用的方法）。这个方法有个弱点：如果某些段落段首不空格或不止空两格，就会有一定的麻烦，换句话说，灵活性不够。

    叶子这里给出另一个方案，能实实在在地让Wordpress保留在可视化编辑其中输入的每个空格。

    首先感谢TinyMCE Entities Patch的作者stringfold，下面的代码是从这个插件中提取出来的。由于原插件过于老迈，其他部分我不确定能用，只用了这个部分。

    add_filter('tiny_mce_before_init', 'preserve_nbsp_chars');
function preserve_nbsp_chars($initArray) {
    $initArray['entities'] = '160,nbsp,'.$initArray['entities'];
    return $initArray;
}

    如果你不懂用这段代码的话，我把它做成了一个插件，点击这里下载，解压后上传到/wp-content/plugins目录中，然后激活插件“keep-blanks”就可以了。

    有什么问题，请在下面反馈，谢谢！

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. 沉迷
    2. 问问matlab:WHY?
    3. NOIP实用算法 1.模拟方法

    ]]>     http://blog.programet.org/2011/04/keep-blanks.html/feed 5     学习使用GTK+ 6.GTK+常用物件及API（按钮） http://blog.programet.org/2011/03/gtk-6.html http://blog.programet.org/2011/03/gtk-6.html#comments Fri, 18 Mar 2011 14:40:02 +0000 最后的叶子 http://blog.programet.org/?p=3973
  • 学习使用GTK+ 4.GTK+常用物件及API（窗口）
  • 学习使用GTK+ 5.GTK+常用物件及API（文本）
  • 学习使用GTK+ 3.使用GtkBuilder、界面设计器Glade和其他GTK+组件
    • ]]>     这一部分内容介绍有关GTK+常用按钮、选择框物件的一些函数，以及相关的使用技巧。如果对内容有疑问，请在下方留言，谢谢！

    GTK+的各种按钮和选择框

    GTK+提供了各种各样的按钮，功能丰富，能满足各种不同的需求。按钮可大致分为下面几种：

    • 普通按钮（GtkButton）、链接按钮（GtkLinkButton）：最常用也最简单，唯一的操作是按一下。
    • 复选框（GtkCheckButton）、双态按钮（GtkToggleButton）：这两种按钮本质是一致的，按钮有两个状态（按下和弹起）。
    • 单选框（GtkRadioButton）、下拉菜单（GtkComboBox）：可以从多个项目中选择一个。
    • 文件选择按钮（GtkFileChooserButton）、颜色选择按钮（GtkColorButton）、字体选择按钮（GtkFontButton）：这些按钮按下后会弹出对话框，供用户选择。
    • 菜单和与菜单相关的物件：用于构建菜单、工具栏等。

    此外还有一些别的按钮，可以提供丰富的细节功能。想用的话请自行查参考。

    Glade对它们提供了很好的支持。尤其是提供了菜单编辑器，菜单完全不用写代码构建，这提供了很大的方便。对于可以在Glade中完成的部分，这里不再多做介绍。

    信号

    按钮和选择框在运行时较少被动态更改，使用这些物件最主要的还是获取信号执行操作。在第三部分的末尾已经介绍了链接信号的基本方法：在Glade中想要连接的信号，输入回调函数名，在程序中编写回调函数。

    对于普通按钮，“clicked”肯定是最常用的一个信号。而对于复选框和双态按钮，应当使用“toggled”信号，不建议使用其他信号代替。因为在这个信号被触发时，按钮的状态已经被改变了，可以立即使用gtk_toggle_button_get_active()函数获得按钮的最新状态。

    技巧：建立物件数组

    有时，按钮在一起时比较便于管理，因而时常会把物件放入数组中管理。这需要在获取物件地址时把物件地址存入数组中。聪明的做法是，在Glade中命名物件时起有规律的名字。

    下面继续编写计算器程序来展示这种手段。

    计算器的0~9这10个按钮操作是类似的，因而可以放在数组中管理。首先为按钮起类似的名字：BNum0,BNum1,BNum2,…,BNum9。获取物件的函数原型如下：

    GObject* gtk_builder_get_object(GtkBuilder *builder, const gchar *name);

    因而可以用这段代码把物件放入一个数组中：

    GtkButton *BNum[10];
gint i;
gchar s[6];
strcpy(s,"BNum_");
for(i=0;i<10;i++)
{
	s[4]=i+'0';
	BNum[i]=GTK_BUTTON(gtk_builder_get_object(builder,s));
}

    小提示：如果物件超过了10个，可以使用sprintf()或者glib中的g_strdup_printf()来得到等同于物件名的字符串。在Glade中复制物件，物件的名字会自动按照末尾数字递增命名，并且物件的属性和信号也会一同被复制。

    在连接信号时，可以把数组里所有类似的信号连接到同一个函数里。注意：回调函数的第一个参数总是GtkObject* widget，即信号对应物件的地址，可以用这个参数来判断是具体是哪个物件发出了信号。

    下面给出最新的获取物件函数。

    void cal_get_widgets(GtkBuilder* gb)
{
	gint i;
	gchar s[6];
 
	w_(gb,WINDOW,WMain);
	w_(gb,SPIN_BUTTON,SAns);
	w_(gb,BUTTON,BPoint);
	w_(gb,BUTTON,BPlus);
	w_(gb,BUTTON,BMinus);
	w_(gb,BUTTON,BMulti);
	w_(gb,BUTTON,BDiv);
 
	strcpy(s,"BNum_");
	for(i=0;i<10;i++)
	{
		s[4]=i+'0';
		BNum[i]=GTK_BUTTON(gtk_builder_get_object(gb,s));
	}
}

    这个程序将在后面的部分中完成。

    快捷键和默认按钮

    在Glade中，还可以为每个按钮分配快捷键（加速键）。选定物件后，点击Glade右下角的“公共”选项卡中的“加速键”右侧的“…”按钮，可以在弹出窗口中指定该物件某个信号的快捷键。当窗口处于激活态时按下快捷键，对应的信号会被触发。

    GTK+中，每个窗口有一个默认物件，某些情况下会被激活——比如在文本框中输入完毕按下Enter（当然这要将文本框的“激活默认”属性置为TRUE），确认按钮（当然它要被设为默认）会被按下。指定一个按钮为默认物件，需要将“公共”选项卡的“可成为默认”和“默认”都置为TRUE。

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. 学习使用GTK+ 4.GTK+常用物件及API（窗口）
    2. 学习使用GTK+ 5.GTK+常用物件及API（文本）
    3. 学习使用GTK+ 3.使用GtkBuilder、界面设计器Glade和其他GTK+组件

    ]]>     http://blog.programet.org/2011/03/gtk-6.html/feed 0     谜之系列(0):线性规划 http://blog.programet.org/2011/02/%e8%b0%9c%e4%b9%8b%e7%b3%bb%e5%88%970%e7%ba%bf%e6%80%a7%e8%a7%84%e5%88%92.html http://blog.programet.org/2011/02/%e8%b0%9c%e4%b9%8b%e7%b3%bb%e5%88%970%e7%ba%bf%e6%80%a7%e8%a7%84%e5%88%92.html#comments Mon, 14 Feb 2011 16:16:38 +0000 DarkRaven http://blog.programet.org/?p=3736
  • 素数有无穷多个的另类证明（三）：被遗忘的证明
  • 素数有无穷多个的另类证明（二）：素数的某个求和式
  • 素数有无穷多个的另类证明（一）：两两互素的无穷序列
    • ]]>     Don’t Panic!

    虽然听起来很可怕，但是线性规划其实是很容易理解的东西。

    简单介绍

    嘛，大家在高中里面也应该做过这样的题目：

    最大化：

    6x+5y

    满足：

    x+y \leq 10 \\2x-3y \leq 5

    这是二维情况下的线性规划，大家当时的解法恐怕都是在平面上画出相应的图形，然后平移目标函数对应的直线来找到目标函数的最优值。

    从这个想法很容易推广到变量个数更多的线性规划问题。比如在拥有三个变量的线性规划中，约束条件由二维时的直线推广到平面，可行域由二维时的半平面推广到半空间。

    同样地n个变量的一般线性规划也可以如此推广（n维超空间，n-1维超平面什么的….）

    如果说三维还在人的想象力所及的范围内，那么n维的线性规划要怎么解呢？

    直觉告诉我们，线性规划的最优解总是在顶点处取到（事实也是这样，证明略），于是我们可以联立变量数个方程，解出顶点坐标，带入目标函数。这样的算法，对于n个变量，m个约束条件的线性规划问题，其复杂度为\dbinom{n+m}{n}

    而这个复杂度也就是线性规划中常用的单纯形算法的最坏复杂度。

    我将不在此介绍单纯形算法。

    以上是对线性规划的简单介绍，下面要讲线性规划问题在网络流问题中一个比较有用的性质，对偶性

    对偶性

    所谓对偶性是指，对于每一个要求目标函数最大化线性规划问题，都有相应的，目标函数是最小化的线性规划问题，这两个问题有相同的最优解，其最普遍的体现就是一些最大/最小定理，比如最大流最小割定理可能是最广为人知的了。

    现在先让我不失一般性地定义一下一个线性规划问题：

    最大化：

    \displaystyle\sum_{j=1}^{n} c_{j}x_j

    满足：

    \displaystyle\sum_{j=1}^{n} a_{ij}x_j \leq b_i \quad i=1,2,3,\cdots,m\qquad{}(*)

    x_j \geq 0 \quad j=1,2,3,\cdots,n

    注：这个定义是“一般的”，任何一个线性规划都可以转化为这种形式（松弛型），具体留给读者思考好了。

    然后定义其对偶式：

    最小化：

    \displaystyle\sum_{i=1}^{m} b_{i}y_i

    满足：

    \displaystyle\sum_{i=1}^{m} a_{ij}y_i \geq c_j \quad j=1,2,3,\cdots,n

    y_i \geq 0 \quad j=1,2,3,\cdots,m

    所谓对偶，就是将约束条件与变量互换（回忆射影几何中的对偶），于是一个最大化问题变成了一个最小化问题，现在要证明的是这两个问题的最优解相同。

    （以下证明来自算法导论第二版，引理29.8）

    引理：线性规划中的弱对偶性

    令\overline{x}为原问题的一个可行解，\overline{y}为对偶问题的一个可行解，则：

    \displaystyle\sum_{j=1}^{n} c_{j}\overline{x}_j\leq\sum_{i=1}^{m} b_{i}\overline{y}_i

    证明：

    \displaystyle\sum_{j=1}^{n} c_{j}\overline{x}_j\leq\sum_{j=1}^{n}\left (\sum_{i=1}^{m}a_{ij}\overline{y}_{i}\right )\overline{x}_j（见对偶式的约束条件）

    \displaystyle= \sum_{j=1}^{n}\left (\sum_{i=1}^{m}a_{ij}\overline{x}_{j}\right )\overline{y}_i

    \displaystyle\leq\sum_{i=1}^{m} b_{i}\overline{y}_i（见原问题的约束条件）

    \hfill \ensuremath{\Box}

    于是现在问题变成这样：只要找到一对可行解\overline{x},\overline{y}，使

    \displaystyle\sum_{j=1}^{n} c_{j}\overline{x}_j=\sum_{i=1}^{m} b_{i}\overline{y}_i

    那么线性规划的对偶性就得到了证明。

    关于这个解的存在性问题的证明，将会涉及到单纯形算法的细节，所以在这里只是简单、不严密的讲一下：

    我们在原问题的约束条件（(*)式）左边加一项，并将不等号变为等号（\displaystyle\sum_{j=1}^{n} a_{ij}x_j + x_{n+i}= b_i \quad i=1,2,3,\cdots,m）

    可以看出，这样并不会改变原问题的最优解。之后通过对变量的互相替换，我们最终可以将目标函数化为如下形式：

    \displaystyle{}z=v'-\sum_{j\in{}N}c'_{j}x_{j}\qquad{}(1)

    N表示所有出现在目标函数中的变量的下标所组成的集合。c'_{j}>0

    那么取\overline{y}=\begin{cases}c'_{n+i}&\text{if } n+i\in N \\ 0 &\text{otherwise}\end{cases}就是对偶问题的最优解。或者令c'_{j}=0,j\notin{}N，那么就是取y=c'_{n+i}。

    当原问题的目标函数化为如(1)的形式后，最优解是明显的，即令x_{j}=0,j\in{}N，取得z_{max}=v'。

    现在只要说明，\overline{y}可以使对偶式的目标函数也取v'值即可。

    取上文中扩展后的c'定义，我将不加解释地说明这一点： \displaystyle \begin{array}{rl} \displaystyle \sum_{j=1}^{n}c_{j}x_j & \displaystyle= v' - \sum_{j=1}^{n+m}c'_{j}x_j \\ & \displaystyle=v' - \sum_{j=1}^{n}c'_{j}x_j - \sum_{i=1}^{m}c'_{n+i}x_i \\ & \displaystyle=v' - \sum_{j=1}^{n}c'_{j}x_j - \sum_{i=1}^{m}\overline{y}_{i}x_i \\ & \displaystyle=v' - \sum_{j=1}^{n}c'_{j}x_j - \sum_{i=1}^{m}\overline{y}_{i}\left (b_{i} - \sum_{j=1}^{n}a_{ij}x_j \right ) \qquad (i) \\ & \displaystyle=\sum_{j=1}^{n}\left ( \sum_{i=1}^{m}a_{ij}\overline{y}_{i} - c'_{j} \right )x_j + \left (v' - \sum_{i=1}^{m}b_{i}\overline{y}_{i} \right ) \end{array}

    因为这个等式对于任意的x_{i},i=1,2,3,\cdots,n，取值都成立，则\displaystyle{}v' - \sum_{i=1}^{m}b_{i}\overline{y}_{i}必定为0（令所有x_{i}=0）

    所以此时\displaystyle\sum_{i=1}^{m}b_{i}\overline{y}_{i} = v' ，命题得证。

    （对于不理解(i)式的人，再看看修改后的约束条件）

    关于线性规划这个基础知识的介绍就到这里，下一篇大概会定义“网络”是什么“流”是什么

    本文由 DarkRaven 创作，转载或引用前请联系我们。

    相关文章：

    1. 素数有无穷多个的另类证明（三）：被遗忘的证明
    2. 素数有无穷多个的另类证明（二）：素数的某个求和式
    3. 素数有无穷多个的另类证明（一）：两两互素的无穷序列

    ]]>     http://blog.programet.org/2011/02/%e8%b0%9c%e4%b9%8b%e7%b3%bb%e5%88%970%e7%ba%bf%e6%80%a7%e8%a7%84%e5%88%92.html/feed 4     NOIP实用算法·教程 下载版 2.0 http://blog.programet.org/2010/11/noip-download-2.html http://blog.programet.org/2010/11/noip-download-2.html#comments Mon, 08 Nov 2010 10:26:31 +0000 最后的叶子 http://blog.programet.org/?p=3383
  • NOIP实用算法·教程 下载版
  • 五年NOIP提高组复赛算法及难度分析
  • NOIP实用算法 目录
    • ]]>     一年多前我们制作了《NOIP实用算法·教程 下载版》。这得到了很多童鞋的支持，在此表示感谢。

    鉴于原版中有若干错误，这里放出新的下载版（2.0），修正了目前已发现的错误。

    点击这里下载。文件是zip格式，大小约40KB。文件中有部分（不涉及教程内容的）页面需要在线观看。

    如果有链接错误，请马上向我们报告（写评论），谢谢~

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. NOIP实用算法·教程 下载版
    2. 五年NOIP提高组复赛算法及难度分析
    3. NOIP实用算法 目录

    ]]>     http://blog.programet.org/2010/11/noip-download-2.html/feed 5     手机上的越墙天梯——Snaptu http://blog.programet.org/2010/10/%e6%89%8b%e6%9c%ba%e4%b8%8a%e7%9a%84%e8%b6%8a%e5%a2%99%e5%a4%a9%e6%a2%af%e2%80%94%e2%80%94snaptu.html http://blog.programet.org/2010/10/%e6%89%8b%e6%9c%ba%e4%b8%8a%e7%9a%84%e8%b6%8a%e5%a2%99%e5%a4%a9%e6%a2%af%e2%80%94%e2%80%94snaptu.html#comments Sat, 23 Oct 2010 13:22:59 +0000 严酷的魔王 http://blog.programet.org/?p=3356
  • 关于《生命游戏》和细胞自动机
  • 夜空下的萤火虫——《众里寻他》番外
  • 深蓝的第一次比赛
    • ]]>     最近我的笔记本悲剧地出了硬件问题，寄回原厂维修，估计还有蛮久的样子……于是有需要的时候只能依靠舍友的救济来完成需要依靠电脑进行的各种活动。如何用手机上推就变成了一个需要解决的问题。

    我尝试过手机访问在线代理网站，发现一个站点速度不错，但是因为不是直接访问，所以每次登陆都要输入一次账号密码，很是麻烦。突然回想起以前曾经在手机上面下过一个传说可以用twitter的软件，叫做Snaptu，官方网站是http://snaptu.com/。

    这是一个免费的java软件，只要能运行java的机器基本上都能够运行它。Snaptu的特色在于它集成了很多社会化网站的功能于一身，例如facebook，twitter，以及天气预报，RSS订阅等实用功能——甚至支持将你的Google Reader内容导入其中。只需要用你的手机访问http://m.snaptu.com/，便可下载到这个java软件。软件的twitter界面大概是这样的（图片截自官网，与实际情况相似）：

    不过这里要补充说明一下：如果想要访问这个网以及正常使用这个软件，你需要将手机的网络接入点设置成cmnet。而不同的手机有不同的设置方法，所以我这里也就不再继续详解了，大家自行去搜索吧。

    这个软件本来是一个面向英国用户的应用集成特色软件，之所以能协助我们翻墙的原理就是它为了方便集中这些应用，弄了一个自己的形式上的”appstore”——其实是免费的store~所以自身带有一个中转服务器，至今没有被墙掉，于是便起到了一个代理的作用，歪打正着地吸引了大量特殊用户。大家赶紧趁其仍健在的时候玩玩吧！

    本文由 严酷的魔王 创作，转载或引用前请联系我们。

    相关文章：

    1. 关于《生命游戏》和细胞自动机
    2. 夜空下的萤火虫——《众里寻他》番外
    3. 深蓝的第一次比赛

    ]]>     http://blog.programet.org/2010/10/%e6%89%8b%e6%9c%ba%e4%b8%8a%e7%9a%84%e8%b6%8a%e5%a2%99%e5%a4%a9%e6%a2%af%e2%80%94%e2%80%94snaptu.html/feed 5     学习使用GTK+ 5.GTK+常用物件及API（文本） http://blog.programet.org/2010/10/gtk-5.html http://blog.programet.org/2010/10/gtk-5.html#comments Tue, 19 Oct 2010 12:28:07 +0000 最后的叶子 http://blog.programet.org/?p=3337
  • 学习使用GTK+ 4.GTK+常用物件及API（窗口）
  • 学习使用GTK+ 3.使用GtkBuilder、界面设计器Glade和其他GTK+组件
  • 学习使用GTK+ 6.GTK+常用物件及API（按钮）
    • ]]>     这一部分内容介绍有关GTK+常用文本类物件的一些函数。如果对内容有疑问，请在下方留言，谢谢！

    GTK+的文本

    显示文字和控制文本框自然是界面重头戏，基本每个窗口都离不开这样的物件。GTK+中和文本有关的物件主要有：文本标签（GtkLabel，以下简称“文本”），输入框（GtkEntry），可编辑多行文本（GtkTextView，以下简称“多行文本”），调节按钮（GtkSpinButton）。各物件有自己的优点。

    • 文本：简单地显示一些文字，使用非常方便，一般用于显示界面上最普通的文字。
    • 输入框：用于让用户输入一行文字，使用方便。
    • 多行文本：用于让用户输入多行文字，或显示一段非常长的文字，可配合滚动区（GtkScrolledWindow）使用来达到很好的显示效果，也可为部分文字设置样式。它的缺陷在于使用繁琐。
    • 调节按钮：用于输入数字，在控制数字输入方面的功能非常强大，其右侧有上下调节数字大小的按钮。

    具体使用哪个物件需要根据实际情况决定。

    访问文本、输入框

    对文本类物件的操作基本相似。对这些物件的动态访问基本归结为以下两种——读取所包含的文字信息（读）、设置所包含的文字内容（写）。其他的设置基本不需要动态改变，初始时在Glade中设置好即可（如果真的需要修改，自己去看参考吧）。

    下面这些函数用于对文本、输入框的读写，函数名字都很好记。

    //写入文本内容
void          gtk_label_set_text(GtkLabel *label, const gchar *str);
//读取文本内容
const gchar*  gtk_label_get_text(GtkLabel *label);
//写入输入框内容
void          gtk_entry_set_text(GtkEntry *entry, const gchar *text);
//读取输入框内容
const gchar*  gtk_entry_get_text(GtkEntry *entry);

    使用调节按钮

    调节按钮是用于操作数字的，因而可以直接向其中写入或者读出实数或整数。

    //设置调节按钮的数值
void          gtk_spin_button_set_value       (GtkSpinButton *spin_button, gdouble value);
//读出调节按钮的数值
gdouble       gtk_spin_button_get_value       (GtkSpinButton *spin_button);
gint          gtk_spin_button_get_value_as_int(GtkSpinButton *spin_button);

    做个实例吧。本系列第三部分做了一个计算器雏形，下面来稍稍完善一下。

    计算器的上方有一个名为SAns的调节按钮，下面增加一个功能：当调节按钮的值的绝对值过大（大于等于常数CAL_ABS_MAX）时，弹出错误提示窗口。

    每个调节按钮对应一个GtkAdjustment，首先应为调节按钮添加一个GtkAdjustment。在Glade中，点“常规”的“调整部件”右侧的“…”，弹出窗口中点“New”。

    此时上方的物件选择栏末尾中会出现一个对象adjustment1，可以更改它的属性，即调节按钮的最值、步长等。

    然后为SAns的信号value-changed添加操作句柄“on_SAns_value_changed”，然后在程序中添加相应回调函数。

    回到程序中，在初始化时，用gtk_spin_button_set_range()修改调节按钮取值范围为[-CAL_ABS_MAX,CAL_ABS_MAX]，再编写回调函数on_SAns_value_changed()，顺便用上上一部分写的函数gtk_show_error()。完整代码如下。

    #include <gtk/gtk.h>
 
#define CAL_ABS_MAX 1e9
 
#define w_(builder,type,name) name=GTK_##type(gtk_builder_get_object(builder,#name))
 
GtkWindow *WMain;
GtkSpinButton *SAns;
 
//显示一个错误提示窗口
void gtk_show_error(gpointer window, const gchar* message, const gchar* title)
{
    GtkWidget *dialog;
    dialog = gtk_message_dialog_new_with_markup(window,
             GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_MESSAGE_ERROR,
             GTK_BUTTONS_OK,
             message);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
}
 
G_MODULE_EXPORT void on_SAns_value_changed(GtkObject* widget, gpointer user_data)
{
    //gdouble在Windows下等价于double
    gdouble d;
    //读取调节按钮的值
    d=gtk_spin_button_get_value(SAns);
    //判断是否需要显示错误提示窗口
    if(d>=CAL_ABS_MAX)
    {
        gtk_show_error(WMain,"Too Large","Error!");
        //设置调节按钮值为零
        gtk_spin_button_set_value(SAns,0);
    }
    else if(-d>=CAL_ABS_MAX)
    {
        gtk_show_error(WMain,"Too Small","Error!");
        //设置调节按钮值为零
        gtk_spin_button_set_value(SAns,0);
    }
}
 
G_MODULE_EXPORT void on_WMain_destroy(GtkObject* widget, gpointer user_data)
{
    gtk_main_quit();
}
 
GtkBuilder* gtk_load_glade(gchar* filename)
{
    GtkBuilder *gb;
 
    gb=gtk_builder_new();
    if(!gtk_builder_add_from_file(gb,filename,NULL))return NULL;
    gtk_builder_connect_signals(gb,NULL);
 
    return gb;
}
 
void cal_get_widgets(GtkBuilder* gb)
{
    w_(gb,WINDOW,WMain);
    w_(gb,SPIN_BUTTON,SAns);
}
 
void cal_widget_init()
{
    //初始化，设置调节按钮取值范围，数值超出此范围时自动调整为边界值。
    gtk_spin_button_set_range(SAns,-CAL_ABS_MAX,CAL_ABS_MAX); 
 
    gtk_widget_show_all(GTK_WIDGET(WMain));
}
 
int main(int argc, char *argv[])
{
    GtkBuilder *gb;
 
    gtk_init(&argc,&argv);
 
    gb=gtk_load_glade("gtk-cal.glade");
    if(gb==NULL)return -1;
    cal_get_widgets(gb);
    cal_widget_init();
 
    gtk_main();
 
    return 0;
}

    在以后的内容中，这个计算器将被逐渐完善。

    访问多行文本

    多行文本的使用比较复杂，涉及几个其他对象的使用。一个多行文本的内容储存在一个缓冲区GtkTextBuffer中，这个缓冲区需要用迭代器GtkTextIter访问、用GtkTextMark标记，文字样式用GtkTextTag设置。

    看起来真的有些复杂。不过最基本的应用还是读、写。下面给出三个函数，可以直接读写多行文本。这几个函数基本够用了。

    //读取多行文本中的文字内容
gchar* gtk_text_view_get(GtkTextView *text_view)
{
    GtkTextBuffer *tb;
    GtkTextIter st,stp;
 
    tb=gtk_text_view_get_buffer(text_view); //获取对应的GtkTextBuffer
    gtk_text_buffer_get_start_iter(tb,&st); //获得起始点
    gtk_text_buffer_get_end_iter(tb,&stp); //获得结束点
    return gtk_text_buffer_get_text(tb,&st,&stp,FALSE); //获得两点间所有字符
}
//在多行文本末尾追加文字，文字样式包含在text_tag中，如果不需要指定样式，text_tag设为NULL
void gtk_text_view_append_with_tag(GtkTextView* text_view, const gchar* text, GtkTextTag* text_tag)
{
    GtkTextBuffer *tb;
    GtkTextIter stp;
 
    tb=gtk_text_view_get_buffer(text_view);
    gtk_text_buffer_get_end_iter(tb,&stp);
    gtk_text_buffer_insert_with_tags(tb,&stp,text,strlen(text),text_tag,NULL); //在结束点处追加字符
    gtk_text_buffer_get_end_iter(tb,&stp);
    gtk_text_view_scroll_to_iter(text_view,&stp,0,FALSE,0,0); //将光标置于结束点
}
//清空多行文本
void gtk_text_view_clear(GtkTextView *text_view)
{
    gtk_text_buffer_set_text(gtk_text_view_get_buffer(text_view),"",0); //设置文本内容为空
}

    此外，样式可以这样新建：

    gtk_text_buffer_create_tag(gtk_text_view_get_buffer(text_view), tag_name, property1, value1, property2, value2, ... , NULL);

    text_view是多行文本名字；tag_name是一个字符串，值不能和别的样式相同；property1,2,3,…各属性名字（字符串形式），可用的属性参见http://library.gnome.org/devel/gtk/unstable/GtkTextTag.html中的Property栏；value1,2,3,…各属性对应的值（字符串形式）。

    如果以上的方法不够用，只好查参考了。

    小提醒：多行文本一般都需要放在滚动区（GtkScrolledWindow）里面。

    处理UTF-8字符串

    要注意的问题是，GTK+内部使用UTF-8编码。在处理非ASCII编码的字符串时，切不可使用C语言string.h里的函数。在UTF-8中，字符含义比较复杂。还好，GLib中提供了很多用于处理多种编码字符串的函数，下面介绍一些用于处理UTF-8字符串的函数。

    在http://library.gnome.org/devel/glib/stable/glib-Unicode-Manipulation.html中介绍了很多有关UTF-8字符串的实用函数。这些函数命名与string.h里的常用函数相近，只是多了前缀g_utf8_，表示是专门用来处理UTF-8字符串的。介绍几个吧。

    • g_utf8_strlen()：统计UTF-8字符串中的字符数。在UTF-8编码中，不同语言的字符所占用的字节数不同（例如一个中文字符占3个字节），因而UTF-8所包含的字符数小于等于它的字节数，并且没有一个固定的关系。这个函数还是很常用且重要的。
    • g_utf8_find_prev_char()：已知某个字符的首地址，查找它前一个字符的首地址。因为不同语言的字符所占用的字节数不同，两个紧邻字符地址之差可能大于1。
    • g_utf8_find_next_char()：已知某个字符的首地址，查找它后一个字符的首地址。
    • g_utf8_strncpy()：拷贝出字符串的前n个字符（而不是前n个字节）。
    • g_utf8_strchr()：找到一个给定的字符最左端出现的位置。UTF-8字符串中字符是gunichar型，相当于一个32位无符号整数，对于非ASCII字符，其值大于127。
    • g_utf8_collate()：比较两个字符串的大小（以字典序靠前的为小）。这个函数的强大之处在于，它可以根据所处的语言环境来判断两个字符串的字典顺序，可以比较任何语言的UTF-8字符串！

    在http://library.gnome.org/devel/glib/stable/glib-String-Utility-Functions.html列出了一些跨字符集的实用函数，适用于任何字符集。其中有一部分常常能用上，比如g_snprintf()和g_strdup_printf()，它们的功能与C语言sprintf类似，都是把一串格式输出写进字符串里（常用于数字和字符混合输出到字符串里），但g_snprintf()和g_strdup_printf()更安全。g_snprintf()需要指定目的字符串长度，避免输出越界；g_strdup_printf()则在函数内部自行申请足够的空间存放目的字符串（注意它返回的字符串废弃之后需要用g_free()释放空间）。

    在http://library.gnome.org/devel/glib/stable/glib-Character-Set-Conversion.html有一些字符集转换的函数，有些需要字符集转换的场合会用得上（比如文件名可能不是UTF-8编码，有时需要转换）。

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. 学习使用GTK+ 4.GTK+常用物件及API（窗口）
    2. 学习使用GTK+ 3.使用GtkBuilder、界面设计器Glade和其他GTK+组件
    3. 学习使用GTK+ 6.GTK+常用物件及API（按钮）

    ]]>     http://blog.programet.org/2010/10/gtk-5.html/feed 0     学习使用GTK+ 4.GTK+常用物件及API（窗口） http://blog.programet.org/2010/10/gtk-4.html http://blog.programet.org/2010/10/gtk-4.html#comments Wed, 06 Oct 2010 19:02:33 +0000 最后的叶子 http://blog.programet.org/?p=3294
  • 学习使用GTK+ 5.GTK+常用物件及API（文本）
  • 学习使用GTK+ 1.构建GTK+编译环境
  • 学习使用GTK+ 6.GTK+常用物件及API（按钮）
    • ]]>     这一部分内容介绍有关GTK+常用窗口类物件的一些函数。如果对内容有疑问，请在下方留言，谢谢！

    GTK+的窗口

    窗口是GTK+最基本的物件之一，物件要被放在窗口里显示。GTK+里，常用的窗口包括顶级窗口（GtkWindow）、对话框（GtkDialog）和消息对话框（GtkMessageDialog）等。

    GTK+有关窗口的操作很多，绝大多数情况下可以满足自定义窗口的需求；但有时候还是不可避免要直接访问底层库GDK。要注意的是，GdkWindow与GtkWindow有很大差异，GdkWindow指一个显示区域，每一个可显示的GTK+物件都对应一个GdkWindow，阅读文档时两者不可混淆。

    窗口类物件在Glade中得到了良好的支持，复杂的窗口建议直接用Glade创建。

    简易消息对话框

    消息对话框是最简易的窗口，如果还在Glade中创建的话，很麻烦且会使Glade文件变得更大。下面这些函数，可以快速创建一个窗口而不需要Glade。

    void gtk_show_info(gpointer window, const gchar* message, const gchar* title)
{
    GtkWidget *dialog;
    dialog = gtk_message_dialog_new_with_markup(window,
             GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_MESSAGE_INFO,
             GTK_BUTTONS_OK,
             message);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(GTK_WIDGET(dialog));
}
 
void gtk_show_error(gpointer window, const gchar* message, const gchar* title)
{
    GtkWidget *dialog;
    dialog = gtk_message_dialog_new_with_markup(window,
             GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_MESSAGE_ERROR,
             GTK_BUTTONS_OK,
             message);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
}
 
gint gtk_show_question(gpointer window, const gchar* message, const gchar* title)
{
    gint i;
    GtkWidget *dialog;
 
    dialog = gtk_message_dialog_new_with_markup(window,
             GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_MESSAGE_QUESTION,
             GTK_BUTTONS_YES_NO,
             message);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    i=gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
 
    if(i==GTK_RESPONSE_YES)
        return 1;
    else
        return 0;
}
 
void gtk_show_warning(gpointer window, const gchar* message, const gchar* title)
{
    GtkWidget *dialog;
    dialog = gtk_message_dialog_new_with_markup(window,
             GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_MESSAGE_WARNING,
             GTK_BUTTONS_OK,
             message);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
}

    以上四个函数分别是一个信息窗口、错误提示窗口、询问窗口、警告窗口，三个参数分别是母窗口、窗口内文字内容、窗口标题。在程序中直接调用函数即可。

    文件选择对话框

    文件选择对话框同样可以不用Glade创建，而直接调用API方便地创建。下面的函数可以创建文件打开对话框和文件保存对话框。

    GtkWidget* gtk_show_file_add_filter(GtkWidget* dialog, const gchar *description, gchar *pattern)
{
	GtkWidget *filter;
	filter=GTK_WIDGET(gtk_file_filter_new());
	gtk_file_filter_set_name(GTK_FILE_FILTER(filter),description);
	gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),pattern);
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),GTK_FILE_FILTER(filter));
	return filter;
}
 
gchar* gtk_show_file_open(GtkWidget* parent_window, const gchar *title, const gchar *filters)
{
    GtkWidget *dialog,*FF[16];
    gchar *filename,des[256],pattern[64];
    long i,j,FFc=0;
 
    dialog = gtk_file_chooser_dialog_new (title,
                                          GTK_WINDOW(parent_window),
                                          GTK_FILE_CHOOSER_ACTION_OPEN,
                                          /*GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,*/
                                          GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                          NULL);
 
    //filters
	for(i=0;i<strlen(filters);i++)
	{
		j=0;
		while(i<strlen(filters) && filters[i]!='|')
			des[j++]=filters[i++];
		if(j>=256)break;
		des[j]=0;
		j=0;
		i++;
		if(i>=strlen(filters))break;
		while(i<strlen(filters) && filters[i]!='|')
			pattern[j++]=filters[i++];
		if(j>=64)break;
		pattern[j]=0;
		FF[FFc++]=gtk_show_file_add_filter(dialog,des,pattern);
		if(FFc>=16)break;
	}
 
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
    {
        filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
        gtk_object_destroy(GTK_OBJECT(dialog));
        return filename;
    }
 
    return NULL;
}
 
gchar* gtk_show_file_save(GtkWidget* parent_window, const gchar *title, const gchar *default_folder, const gchar *default_name, const gchar *filters)
{
    GtkWidget *dialog,*FF[16];
    gchar *filename,des[256],pattern[64];
    long i,j,FFc=0;
 
    dialog = gtk_file_chooser_dialog_new (title,
                                          GTK_WINDOW(parent_window),
                                          GTK_FILE_CHOOSER_ACTION_SAVE,
                                          /*GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,*/
                                          GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                          NULL);
    gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
    if(default_folder[0]!=0)gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_folder);
    gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), default_name);
 
    //filters
	for(i=0;i<strlen(filters);i++)
	{
		j=0;
		while(i<strlen(filters) && filters[i]!='|')
			des[j++]=filters[i++];
		if(j>=256)break;
		des[j]=0;
		j=0;
		i++;
		if(i>=strlen(filters))break;
		while(i<strlen(filters) && filters[i]!='|')
			pattern[j++]=filters[i++];
		if(j>=64)break;
		pattern[j]=0;
		FF[FFc++]=gtk_show_file_add_filter(dialog,des,pattern);
		if(FFc>=16)break;
	}
 
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
    {
        filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
        gtk_widget_destroy (dialog);
        return filename;
    }
 
    //destroy
    gtk_widget_destroy (dialog);
    for(i=0;i<FFc;i++)
    	gtk_object_destroy(GTK_OBJECT(FF[i]));
 
    return NULL;
}

    gtk_show_file_open()建立一个文件打开窗口供用户选择文件，参数依次是母窗口、标题、过滤器。

    gtk_show_file_save()建立一个文件保存窗口供用户选择文件，参数依次是母窗口、标题、默认文件夹、默认文件名、过滤器。

    其中“过滤器”是一串字符，字符内用“|”分离，其形式像这样：文件类型名称1|对应通配符1|文件类型名称2|对应通配符2|……

    使用GDK函数

    GTK+提供好了丰富的功能，但也有缺陷——某些常用功能无法直接使用，需要访问GDK库。下面这个函数，用来确定窗口是不是处于全屏状态。

    gboolean gtk_window_is_fullscreen(GtkWindow* window)
{
	return (gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(window))) & GDK_WINDOW_STATE_FULLSCREEN) == GDK_WINDOW_STATE_FULLSCREEN;
}

    其他用法，请参阅GTK+参考。

    本文由 最后的叶子 创作，转载或引用前请联系我们。

    相关文章：

    1. 学习使用GTK+ 5.GTK+常用物件及API（文本）
    2. 学习使用GTK+ 1.构建GTK+编译环境
    3. 学习使用GTK+ 6.GTK+常用物件及API（按钮）

    ]]>     http://blog.programet.org/2010/10/gtk-4.html/feed 3