|
C++ 中捕获整数除零错误
继承自 C 的优良传统, C++ 也是一门非常靠近底层的语言, 可是实在是太靠近了, 很多问题语言本身没有提供解决方案, 可执行代码贴近机器, 运行时没有虚拟机来反馈错误, 跑着跑着就毫无征兆地崩溃了, 简直比过山车还刺激. 虽然 C++ 加入了异常机制来处理很多运行时错误, 但是异常机制的功效非常受限, 很多错误还没办法用原生异常手段捕捉, 比如整数除 0 错误. 下面这段代码 #include <iostream>
int main()
{
try {
int x, y;
std::cin >> x >> y;
std::cout << x / y << std::endl;
} catch (...) {
std::cerr << "attempt to divide integer by 0." << std::endl;
}
return 0;
}
输入 "1 0" 则会导致程序挂掉, 而那对 try-catch 还呆在那里好像什么事情都没发生一样. 像 Python 一类有虚拟机环境支持的语言, 都会毫无悬念地捕获除 0 错误. 使用信号 不过, 底层自然有底层的办法. 这得益于硬件体系中的中断机制. 简而言之, 当发生整数除 0 之类的错误时, 硬件会触发中断, 这时操作系统会根据上下文查出是哪个进程不给力了, 然后给这个进程发出一个信号. 某些时候也可以手动给进程发信号, 比如恼怒的用户发现某个程序卡死的时候果断 kill 掉这个进程, 这也是信号的一种. 这次就不是 C 标准了, 而是 POSIX 标准. 它规定了哪些信号进程不处理也不会有太大问题, 有些信号进程想处理也是不行的, 还有一些信号是错误中断, 如果程序处理了它们, 那么程序能继续执行, 否则直接杀掉. 不过, 这些错误处理默认过程都是不存在的, 需要通过调用 signal 函数配置. 方法类似下面这个例子 #include <csignal>
#include <cstdlib>
#include <iostream>
void handle_div_0(int)
{
std::cerr << "attempt to divide integer by 0." << std::endl;
exit(1);
}
int main()
{
if (SIG_ERR == signal(SIGFPE, handle_div_0)) {
std::cerr << "fail to setup handler." << std::endl;
return 1;
}
int x, y;
std::cin >> x >> y;
std::cout << x / y << std::endl;
return 0;
}
可以看出, signal 接受两个参数, 分别是信号编号和信号处理函数. 成功设置了针对 SIGFPE (吐槽: 为什么是浮点异常 FPE 呢?) 的处理函数 handle_div_0, 如果再发生整数除 0 的惨剧, handle_div_0 就会被调用. handle_div_0 的参数是信号码, 也就是 SIGFPE, 忽略它也行. 底层机制
Posted at Jul 24 2010 - 13:17:37
Permanent Link:
/p/100
Load full text
|
Post tags:
POSIX
C
Exception Handling
Signal
C++
|
|
C++ 转移构造
这篇文章中的例子均可在 GCC 4.5.1 版本和 Clang 2.8 版本编译, 在某些较老或优化不尽相同的编译器上, 下面的例程可能并不能获得与文中所述一致的结果. 不过, 这篇文章的重点并非讲述 C++ 中关于复制构造函数的优化, 而是为了说明 C++0x 标准中出现的 Move Semantic 所试图解决的问题之一, 所以对关于复制构造函数的例子有大致理解即可. 重点是, 如果希望完整地编译文中最后一部分中出现的任何 0x 标准相关的代码, 强烈推荐 GCC 4.5.x 版本编译器. 废话少说, 先来一段代码: #include <iostream>
struct cp_ctor_doubling {
cp_ctor_doubling(int ii)
: i(ii)
{}
cp_ctor_doubling(cp_ctor_doubling const& rhs)
: i(rhs.i * 2)
{}
int const i;
};
cp_ctor_doubling create(int i)
{
return cp_ctor_doubling(i);
}
int main()
{
cp_ctor_doubling c(create(10));
std::cout << c.i << std::endl;
return 0;
}
问: 输出多少? A. 10 B. 20 C. 40 D. 以上答案都不正确. 嗯, 也许有得到 B 和 C 的, 得到 D 的同学也许该试着为自己的编译器报个 bug 了, 如果得到 A, 那么恭喜, 您的编译器已经具备对于复制构造函数最基本的优化能力了. C 语言忠实信徒揶揄 C++ 编译器会背着程序员做的 "额外的事情" 时, 历来会想到 C++ 的类复制构造函数. 然而, 现实不仅仅是这样, 编译器还会做出更多额外的事情, 比如把不必要的复制构造函数调用优化掉, 或者更准确地说, 把一些临时对象给优化掉, 于是复制构造函数根本不会被调用到. 如果对上述例子中的编译优化有任何疑虑, 可以尝试下面这段代码 #include <iostream>
struct cp_ctor_not_impl {
cp_ctor_not_impl(int ii)
: i(ii)
{}
cp_ctor_not_impl(cp_ctor_not_impl const&);
int const i;
};
cp_ctor_not_impl create(int i)
{
return cp_ctor_not_impl(i);
}
int main()
{
cp_ctor_not_impl c(create(10));
std::cout << c.i << std::endl;
return 0;
}
Posted at Jul 17 2010 - 16:27:35
Permanent Link:
/p/94
Load full text
|
Post tags:
C++
C++11
Move Semantic
Copy Constructor
|
|
C++ 中的左值
请使用 x86 32位 ArchLinux GCC 4.5.0 环境编译文中 C++ 示例代码, 不过只要是 GCC 或 clang++ 编译结果应该都相仿. 作为一个特别的语言, C++ 中的左值是*语义*概念而非*语法*概念, 这一点甚至也可以认为是沿袭自 C 语言. 在任何其他语言中讨论 “什么是左值” 这个概念时, 会简短使用 “变量可以是左值”, “表达式不能是左值”, “常数不能作为左值” 等等, 诸如 “变量”, “表达式”, “常数” 这些都是语法概念, 所以刚才这些说法都是左值的语法约定. 确实一些语言使用语法约束来规定左值, 比如 Python, 下面的 Python 代码 class A:
pass
a = A()
a + 1 = 0
编译时会报 “SyntaxError: can’t assign to operator”, 是 *Syntax* 哦. -甚至连- JS -这样乱的语言-也有类似的例子, 比如 var f = function() {};
f() = 0;
在执行的时候会报 "ReferenceError: Invalid left-hand side in assignment" --- Chromium. 在 C 里面表达式, 或者函数的返回值, 或者两者的混合, 只要语法恰当, 返回值类型又是一个可写指针, 那么通过对该指针引用的方式来赋值, 如 int* f() { return NULL; }
*(f() + 1) = 0;
这一特性在 C++ 那放荡不羁的类型系统里得到了极大的加强, 完全不再受制于语法的约束, 编译器只需要先根据运算符优先级搭起语法树, 至于左值判定什么的都留在以后的语义分析再来. 而这一切的开端仅仅是因为 C++ 支持一个指针的替代, 也就是引用, 这样连前缀星号都省略了. 另一方面, C++ 中的运算符重载机制又极大地扩展其左值概念的超凡脱俗, 并且 C++ 程序员似乎从来也未有过 “哦, 这只是个示例程序, 尽量别引入复杂特性” 这样的想法, 即使是经典的 Hello World 程序中, 也毫不吝惜地显摆着运算符重载这种高级特性. #include <iostream>
int main()
{
std::cout << "Hello, world\n";
}
从这个例子扩展出一个赋值语句几乎毫不费力, 只需要在函数体第一行加个 = 之后随手发挥就好. #include <iostream>
int main()
{
std::cout << "Hello World\n" = std::cerr;
return 0;
}
当然这份代码会报错但不是因为左值不合理, 而是 --- 赋值操作符被设为私有函数或赋值操作符重载被删除了 (C++11 中). 如果希望的话, 可以进一步参考下面这个操作符重载错乱的例子 (它可能由一位危险的 C++ 实习生在主键盘区 += 坏掉的机器上编写的) struct type {
int x;
type& operator+(type& rhs)
{
this.x = rhs.x;
return *this;
}
type& operator=(type& rhs)
{
this.x += rhs.x;
return *this;
}
};
int main()
{
type a, b, c;
a + b = c;
return 0;
}
所以在 C++ 的世界里, 左值跟赋值运算操作符已经没有半点关系了, 倒是只要类型能够匹配上, 运算符重载就能通过编译, 看起来再离奇的算式都没问题. 不过, 如果非要扯赋值运算符, 它跟其它二元运算符有什么不同? 这差异还确实有, 那就是, 赋值运算符必须是成员非静态的, 也就是说下面的编译无法通过
Posted at Jun 19 2010 - 13:05:49
Permanent Link:
/p/85
Load full text
|
Post tags:
C++
Left Value
Operator Overload
|
|
char** 不能赋值给 char const**
C 和 C++ 允许把指向 "某物" 的指针赋值给指向 "不可改变" 的 "某物" 的指针, 如 char* call = "fsck";
char const* call_const = call;
而且, 如果确定不会更改所知向的对象, 那么推荐加上 const, 这是 C++ 的代码编写建议之一. 但是, 要把指向 “某物” 的二级指针赋值给... 见鬼, 简单的说, 下面这种赋值, 任何一个负责任的 C++ 编译器会报出指针不兼容错误: char* call = "fsck";
char** ptr_to_call = &call;
char const** ptr_const_to_call = ptr_to_call; // error
C/C++ 这样做, 目的其实是在于防范将 char const* 赋值给 char* 的意外行为. 这样说也许很难理解, 那么请看下面这段示例代码 Code Snippet 0-0
char const* CALL = "fsck";
void bind(char const** m)
{
*m = CALL;
}
int main(void)
{
char* s;
bind((char const**)&s); // explicit convert
s[1] = 'u'; // crash on write
return 0;
}
在调用 bind 时, 采取强制转换来规避编译错误. 而此时调用 bind 就出现了问题, 它把 char const* 类型的 CALL 变量赋值给了实际上是 char* 的 s, 结果就是在紧接下来的那个赋值中, 程序由于尝试去写只读内存区而崩溃. 有崩溃有真相, 这就是对标题的解答. 另一个类似的例子是, 子类对象的二级指针不能赋值给父类对象的二级指针, 如 Code Snippet 0-1
struct base {};
struct inherit : base {};
void f(void)
{
inherit** i = NULL;
base** b = i; // error
}
Posted at Apr 25 2010 - 05:12:33
Permanent Link:
/p/83
Load full text
|
Post tags:
C
C++
const
|
|
GCC 的花招: 嵌套函数
这里所说的 GCC 不是 GNU Compiler Collection, 而是单单指代 GNU C Compiler. 这篇文章并不打算讲标准 C 中的任何东西, 而是要聊聊一个 GCC 的特性: 嵌套函数. 先来个例子, C 版的 for_each 结合嵌套函数 (必须存为 .c 文件, 使用 gcc 编译才能通过, g++ 压力大) #include <stdio.h>
void for_each(int* begin, int const* end, void (* fn)(int*))
{
while (begin < end) {
fn(begin++);
}
}
#define ARRAY_SIZE 5
int main(void)
{
int a[ARRAY_SIZE];
int n;
void read(int* x)
{
scanf("%d", x);
}
for_each(a, a + ARRAY_SIZE, read);
scanf("%d", &n);
void add(int* x)
{
*x = *x + n;
}
for_each(a, a + ARRAY_SIZE, add);
void print(int* x)
{
printf("%d ", *x);
}
for_each(a, a + ARRAY_SIZE, print);
printf("end\n");
return 0;
}
这代码的紧凑程度虽然跟闭包没得比, 但是使用与定义能放在一起, 就算是一大进步了. 另一个福利在 add 函数, 它引用了一个局部变量 n, 是在外层函数 main 中定义的. 而 n 的使用并不在 main 的可控范围内, 也许它绕过 for_each 的栈帧, 再继续向上被 add 引用. 这听起来像魔法一样, 幸而 gcc 是个开源软件, 不必担心使用这个特性时会让自己的灵魂落入某个兼职程序员的邪恶巫师手中. 但是这到底是如何实现的呢? 要我讲解 gcc 源码我还没有这个能力, 不过 gcc 有个功能可以让我们比较方便地窥探出其中的技术内幕 $ gcc 源文件 -S -o 目标文件这样源文件会被编译成汇编指令, 接着分析汇编指令好了. 上面那个例子情况比较复杂, 不妨分析下面这段简短的代码 void func(int a, int* b, int c)
{
int nested(void)
{
return a + c;
}
*b = nested();
}
这段代码在我机器上 (环境: x86 / Ubuntu 9.10 / GCC 4.4.1) 编译得到的汇编代码如下
Posted at Apr 18 2010 - 08:12:32
Permanent Link:
/p/82
Load full text
|
Post tags:
Assembly
GCC
for_each
Nested Function
|
|
STL 悲剧之 for_each
这篇文章谈一个我使用 STL 中 for_each 的负面心得. 我对这个东西在当前 C++ 语法下约束是否能广泛使用持有怀疑态度, 至于能否替代所有的 for 循环, 我持完全否定观点! 如果您发现文中提及的这档子事情本质上是我不了解 STL 而自寻死路, 请不吝赐教, 在下方回复, 在下感激不尽. 在 Google 中输入 "for_each" 然后猛击 "I’m feeling lucky", 这时我幸运地跳转到大名鼎鼎的 sgi 的网站里, 页面中有个例子 template<class T> struct print : public unary_function<T, void>
{
print(ostream& out) : os(out), count(0) {}
void operator() (T x) { os << x << ' '; ++count; }
ostream& os;
int count;
};
int main()
{
int A[] = {1, 4, 2, 8, 5, 7};
const int N = sizeof(A) / sizeof(int);
print<int> P = for_each(A, A + N, print<int>(cout));
cout << endl << P.count << " objects printed." << endl;
}
从泛型党的视角看来, 这例子非常不错, 完备而规范地演示了 for_each 的用法. 从此泛型党成了大赢家, 除了 for_each 内部, 外面的代码再也不需要 for 这个关键字了. 而那些说写 C++ 代码像谈话一样简短, 基本上泛型编程完全不及格的程序员, 在写上面功能的时候一般会这样做 int main()
{
int A[] = {1, 4, 2, 8, 5, 7};
const int N = sizeof(A) / sizeof(int);
int i;
for (i = 0; i < N; ++i)
cout << A[i] << ' ';
cout << endl << i << " objects printed." << endl;
}
在喷这个改编版的丑陋之前, 不妨先淡定下来, 想想这个例子到底想做什么, 无非是给个数组 (或者其它什么容器) 把每个成员输出 (或者做个什么其它简单的操作), 并记录被操作的元素个数. 然而, 完成这个操作的代码量与它的功能相比, 臃肿得令人发指. 所以, 在用了几次 for_each 之后, 我完全丧失了当初的激情, 变得极其懒惰, 不愿意把简单的操作抽取到函数外部构造成一个对象然后传递给 for_each; 在维护自己以前写的代码时, 也会偷偷把 for_each 改回 for 循环, 因为有的时候我实在不知道伙伴们把我弄出来的那个函数对象类型给维护到哪里去了. 当然, 我并不认为这是 for_each, 或者 STL, 或者泛型的错. 在我心目中, 泛型思想是风骚的, for_each 的设计是超前的, 问题出在 C++ 语法这个悲剧帝身上, 或者说, 硬要用 C++ 这个传统的面向过程加面向对象语言的语法来包装对象, 来实现类似高阶函数这种函数式编程中的特性, 是悲剧的根源所在. 不仅是 for_each, 连 find_if 等类似的 STL 函数都差不多一样的下场, 与其构造一个精妙绝伦的函数对象类型, 程序员还不如老老实实写个破循环来得实在. 一个振奋人心的消息是, C++ 新标准即将发布了, 它会支持闭包对象, 那样的话, for_each 以及其它函数就不会像现在这么处境尴尬了.
Posted at Apr 17 2010 - 13:17:47
Permanent Link:
/p/81
Load full text
|
Post tags:
C++
STL
for_each
|
|
STL set 悲剧指导
这篇文章谈一个我使用 STL 中 set 容器的负面心得. 是的, 我已经被这丫的杀得超神了, 快来人阻止它吧! 如果您发现文中提及的这档子事情本质上是我不了解 STL 而自寻死路, 请不吝赐教, 在下方回复, 在下感激不尽. 最坏对数时间插入, 删除, 查询, 迭代遍历, 这些听起来都无比诱人, 它们由 STL 中的 set 容器鼎力支持. 然而, set 的只读制度是非常龌龊的, 简而言之, 只要你敢往这个坑里面放, 你就得接受它们以后再也无法修改的命运. 比如下面这段例子 #include <set>
#include <string>
using std::set;
using std::string;
struct student {
string name;
int grade;
student(string const& name_, int grade_)
: name(name_)
, grade(grade_)
{}
bool operator<(student const& rhs) const
{
return name < rhs.name;
}
bool operator==(student const& rhs) const
{
return name == rhs.name;
}
};
int main(void)
{
set<student> students;
students.insert(student("Li Lei", 5));
students.insert(student("Han Meimei", 5));
students.insert(student("Jim Green", 5));
for (set<student>::iterator i = students.begin();
students.end() != i;
++i)
{
++(i->grade);
}
return 0;
}
student 类的 key 是 name, 跟 grade 没有关系, 原则上来说, 修改后者并不会破坏 set 的存储结构. 然而, 编译器一棒子打死, 不许改, 除非剩下的成员全部 mutable 修饰. 只读制度悲剧的根源在于, set 所谓的 key 撑死只是个假象, value_type 这玩意儿就是 key_type 本身. 伪 key 导致的不仅仅是不能改, 重要的是还不能查! 看看 set::find 函数的参数, 要的又是阴魂不散的 key_type. 这意味着什么? 意味着 Han MM 同学报出她名字的时候, 还查不出她几年级, 而必须要利用她的名字, 伪造一个充气娃娃放进去才能找到! 看到这里我就败了, 这明摆着就是不让我用 set, 让我转投 map 么? 一个也许可行的方案是 #include <map>
#include <string>
using std::map;
using std::string;
struct student_periphery {
int grade;
};
map<string, student_periphery> students;
这样建模的话也是够狗血的, 如果哪个函数拿着一份 student_periphery 问怎么查出学生姓名, 那就更悲剧了.
Posted at Mar 12 2010 - 08:34:52
Permanent Link:
/p/79
Load full text
|
Post tags:
set
C++
STL
|
|
django 架设网站入门指南[贰]
上节回顾 – ORM 和数据库创建 admin 应用 打开 guestbook/urls.py 仔细研究一下注释, 会看到有几行写着, 取消注释来激活 admin. django 的 admin 应用是一个非常不错的后台. 现在就来开启它吧 from django.conf.urls.defaults import *
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
# Example:
# (r'^guestbook/', include('guestbook.foo.urls')),
# Uncomment the admin/doc line below and add 'django.contrib.admindocs'
# to INSTALLED_APPS to enable admin documentation:
# (r'^admin/doc/', include('django.contrib.admindocs.urls')),
# Uncomment the next line to enable the admin:
(r'^admin/', include(admin.site.urls)),
(r'^$', 'guestbook.home.views.display'),
(r'^echo/$', 'guestbook.home.views.echo'),
(r'^save/', 'guestbook.home.views.save_message'),
)
因为是应用, 所以呢, 还得去 settings.py 登记 INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.admin',
'guestbook.home',
)
最后要记得执行数据库同步来创建 admin 相关的表 $ guestbook/manage.py syncdb 现在转到 http://localhost:8000/admin/ 会看到登录提示页面啦. 现在填入第一次 syncdb 时输入的帐号密码就能登入了. 不过现在的 admin 还很挫, 甚至不能管理留言. 进入 guestbook/home 目录, 创建 admin.py 源文件, 加入如下内容 from guestbook.home.models import Message
from django.contrib import admin
admin.site.register(Message)
刷新页面, 唉, 没有反应, 因为服务器仅监视那些改动过的文件并重新载入, 这次是单独添加的文件所以没有自动重置, 所以得 重启服务器才行. 然后, 就能在 admin 应用中看到留言对象并修改它们了. 定制 admin
Posted at Feb 04 2010 - 10:14:52
Permanent Link:
/p/77
Load full text
|
Post tags:
django
Tutorial
Web Server
Python
|
|
django 架设网站入门指南[壹]
上节回顾 – 配置 基本视图和逻辑数据库配置 仍然在 settings.py 中, 找到 DATABASE_ 开头的项目. 现在用 sqlite3 作为数据库, 它已经集成在 python 2.5 以后的版本中, 这样就省去了安装配置的环节. 现在修改这些项目 DATABASE_ENGINE = 'django.db.backends.sqlite3'
DATABASE_NAME = 'guestbook/db_file'
这里 DATABASE_NAME 同样需要给出文件的绝对路径, 原理跟之前模板目录那个一样, 如果不能确定每次的工作目录, 那么就填绝对 db_file 的路径吧. 保存设置, 然后执行数据库同步操作 $ guestbook/manage.py syncdb会输出提示 Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no):
这些是 django 为内置的用户, 会话等类型建立的表, 最后询问是否立即建立一个超级用户. 这里答 yes (仅一个 y 是不行的唉), 然后输入用户名, 电子邮箱和密码. 最后会建立表的索引, 然后结束. 现在, 你可以在 guestbook 目录下看到文件 db_file 了, 它是数据库使用的文件. ORM 和数据库操作 django 的 ORM 非常轻松. 打开 home 目录下的 models.py, 建立留言类型 from django.db import models
class Message(models.Model):
name = models.CharField(max_length=32)
content = models.CharField(max_length=32)
dt = models.DateTimeField(auto_now=True)
注, 使用 django 的 ORM, 该类型需要继承于 models.Model, 而要往数据库中放的数据项, 需要是 models 模块中的对应的域类型. 至于 auto_now=True, 它指出时间和日期在该对象插入数据库时自动使用当前日期时间. 类型弄好了, 得再同步一次数据库. 这些操作可以不重启服务器 $ guestbook/manage.py sql home
$ guestbook/manage.py syncdb
回到 guestbook/home/views.py, 增加函数 save_message, 让它将表单数据存入数据库, 并重定向回到首页
Posted at Feb 03 2010 - 14:09:53
Permanent Link:
/p/76
Load full text
|
Post tags:
Web Server
Tutorial
Python
django
ORM
|
|
django 架设网站入门指南[零]
安装 根据 django 官方文档, 需要 python 2.3 或更高版本. 不过按现在的 python 普及程度, 想必大家的机器上都有 python 2.5 或 2.6 了. 我的操作系统是 ubuntu 9.10, 自带的是 2.6 版本. debian 用户安装 django 很简单, 只需要 # apt-get install python-django就可以了, 其它发行版看有没有类似的方法. 或者在 官方站点下载源代码安装 祝好运. 建立项目 startproject 首先找到一个地方, 建立一个项目 guestbook, 我们将在这个项目中搭建一个留言板. $ django-admin startproject guestbook有些系统中 django-admin 并非一个命令, 需要 $ python django-admin.py startproject guestbook 执行完这个之后, 当前目录下会创建一个名为 guestbook 的目录, 里面包含了一个最简单的服务器: 显示一个主页. 执行 $ python guestbook/manage.py runserver启动后会看到类似以下输出 Validating models...
0 errors found
Django version 1.1.1, using settings 'guestbook.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
这时, manage.py 已经在本地 8000 端口创建了一个服务器, 赶快打开浏览器去访问吧! 为 guestbook/manage.py 加上可执行属性 (在 ubuntu 9.10 下该属性已经自动添加了) $ chmod u+x guestbook/manage.py创建应用 startapp 在 django 世界的哲学里, 每个功能称之为一个应用. 创建应用也使用 manage.py 来完成. 比如现在用以下命令创建一个首页应用 $ guestbook/manage.py startapp home这时 guestbook 目录下会多出一个 home 目录, 里面有这些文件 __init__.py models.py tests.py views.py 比较烦的是, 这时得回去修改设置, 打开 settings.py 查找 INSTALLED_APPS, 在这一坨里面加一行 INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'guestbook.home',
)
这样 home 应用才算是有了名分. 好, 现在再来实现功能. 因为现在只是处理页面, 所以只需要在 guestbook/home/views.py 里面修修补补就好了. 打开它, 其实相当于是个空文件, 把这一段代码放进去 from django.http import HttpResponse
def display(req):
return HttpResponse('<html><body>hello, django!')
我知道你已经不耐烦了, 如果你曾经写 php 的话. 不过现在还有最后一步, 修改路径映射. 打开 guestbook/urls.py, 在里面加一句话
Posted at Feb 03 2010 - 05:02:06
Permanent Link:
/p/74
Load full text
|
Post tags:
Web Server
Tutorial
django
Python
|
|
Makefile 与 C 语系头文件依赖自动解析
h1. 如何获得源文件依赖的头文件? 这一部分内容与 Makefile 毫无关系, 它由编译器完成. 以 g++ 为例, 可以尝试使用以下方法输出 .cpp 文件依赖的头文件 g++ -M [your cpp file]
乱糟糟的, 不是吗? 这是因为 g++ 把依赖的库文件也给列出来了. 忽略库文件, 则使用这样的命令 g++ -MM [your cpp file]
显然, 这些东西扔到标准输出是毫无用处的, 可以对其进行重定向 g++ -MM [your cpp file] > [some file]
但是这还是有问题, 只把依赖关系放进文件当然不行, 编译源文件的指令还没弄出来呢. 下面就得另外想办法了. h1. 怎么添加编译指令并运行它们? 添加指令本质上就是追加文件内容, 方法有难有简单, 最简单的无非是写个脚本 echo 并追加重定向到文件中. 在这篇粗陋的文章里就用这招了. 好, 写个 Makefile 脚本 [target.o]:[your cpp file]
....g++ -MM $< > Makefile.tmp
....echo "....g++ $< -c" >> Makefile.tmp
....make -f Makefile.tmp
这里的四个点号 (....) 表示一个制表符, 嗯, 是的, Makefile 只能用万恶的制表符来缩进, 而且还必须缩进; Makefile.tmp 一定不要是当前的 Makefile, 要不然就出现文件覆盖的悲剧了... 结果就是, 一旦 make 到这个目标, 它会生成一串依赖关系和构建方法到另一个 Makefile, 然后把编译这等脏活累活都甩给那个倒霉的家伙. h1. 怎么转移目标? 如果上述目标仍然写成 xxx.o : xxx.cpp, 那么如果仅仅是依赖的头文件被修改了, 这个目标仍然不会被 make 到. 一个很挫的方法是, 不要把目标定为 xxx.o 文件, 相反, 弄成一个永不会生成的目标比较好, 比如叫 xxx.d 这个名字. 下面上一个完整的例子. 这个例子中有个叫做 DEP 的 Makefile 变量没有被声明过, 嗯, 这将是你的事情. 请将所有需要编译并连接的 cpp 源文件列个表, 然后修改它们的后缀变成 d, 那么 DEP 的值就是这个表. Code Snippet 0-0
CXX=g++
CXXFLAGS=-Wall -pg
MKTMP=Makefile.tmp
all:object
object:$(DEP)
....$(CXX) $(CXXFLAGS) *.o -o $@
%.d:%.cpp
....$(CXX) -MM $< > $(MKTMP)
....echo "....$(CXX) $< $(CXXFLAGS) -c" >> $(MKTMP)
....make -f $(MKTMP)
clean:
....rm -f *.o
....rm -f test.out
....rm -f $(MKTMP)
再次提醒, 制表符出没注意. (可利用编辑器的全文替换, 4 点换成 1 制表符) 假如现在目录下有 main.cpp, class0.cpp, class1.cpp, 那么定义 DEP=main.d class0.d class1.d
将这句话插进上述源码中的开头位置然后 make 即可. h1. 怎么收拾掉乱七八糟的输出? 接脏活的临时工经常会反馈出一些无聊的信息, 比如进入这个离开那个的, 如果希望保持控制台的清洁, 那么把不想看的都扔进垃圾桶吧 make > /dev/null
不要担心看不到 warning 和 error, 它们是通过 stderr 输出的, 而上述重定向只会干扰 stdout.
Posted at Dec 07 2009 - 11:34:35
Permanent Link:
/p/63
Load full text
|
Post tags:
C
C++
Makefile
|
|
编译期数值计算程序设计思路
阅读这篇文章需要了解基本的 C++ 模板语法规则, 以及模板的泛化, 偏特化, 当然还包括完全特化这些基本概念. 这篇文章将给出基于 C++ 模板的 Metaprogramming 程序设计中需要注意的事项以及渐进式设计思路. 0. 基础这一段介绍 Metaprogramming 基础, 包括模板模式匹配规则, 使用模板实现循环或分支的基本方法. 对 Metaprogramming 已经有了解的同学可以跳过这一段. 本质上来说, 现代计算机的核心任务是数值计算, 周边任务是 I/O. 现代几个主流的编程语言, 如 C/C++/Java, 它们的语法组织方式与现代计算机的主流体系结构是 "平行" 的, 即, 语句的先后顺序表示它们的逻辑顺序, 而这种顺序与人的一贯思维顺序又是相同的 (在计算机中表达式的计算顺序会与书写顺序稍有不同, 但却很符合人类的思路); 可以说这是什么样的爹生什么样的崽, 什么样的人造什么样的语言和计算机. 然而, 在 C++ 模板世界中, 这个规则被打破了. 从分类上来说, Metaprogramming 更类似于函数式编程, 而不是传统的 C++ 程序设计. 在这个异世界中, 程序员不被允许使用循环或者分支语句, 包括函数返回语句都不允许: 在函数式编程中起码还有函数返回, 而在 Metaprogramming 中, 由于一切函数都没有被调用 (还在编译呢), 因此一切的值都谈不上返回, 它们只是存在于模板符号表中, 一旦编译结束便烟消云散. 当然, 没有循环, 分支这些编程语言中的基本元素, 并不意味着程序员只被允许设计顺序程序. 只不过, 在这里, 一切分流动作都被转化为了另一个语言特性: 模式匹配. (这一点与函数式编程非常相似) 下面一段代码展示了模式匹配的威力: Code Snippet 0-0
#include <iostream>
template <unsigned I>
struct limit_to_2
{
static unsigned const R = 2;
};
template <>
struct limit_to_2<1>
{
static unsigned const R = 1;
};
template <>
struct limit_to_2<0>
{
static unsigned const R = 0;
};
int main(void)
{
std::cout << limit_to_2<0>::R << std::endl;
std::cout << limit_to_2<1>::R << std::endl;
std::cout << limit_to_2<2>::R << std::endl;
std::cout << limit_to_2<3>::R << std::endl;
return 0;
}
模板 limit_to_2 为传入的整数设置了一个上限, 当传入模板的参数为 0 或者 1 时内部定义的 R 值与参数相同, 否则将 R 设置为 2. 这看起来很像是 switch-case 语句, 0 和 1 分别是两个 case, 而未特化的模板则是 default. 但是, 这样做有一些不方便, 如果所设的上限非常高, 那岂不是要为低于限制的情况写很多特化? 所以引入分支是非常必要的. 下面这个例子展示了如何利用模式匹配来实现编译期分支:
Posted at Dec 02 2009 - 03:00:11
Permanent Link:
/p/50
Load full text
|
Post tags:
Template
Metaprogramming
C++
|
|
划分问题与连续自然数幂和之通项公式
无限区间上 n 个不同的点可以把该区间分为多少段? 答案很明显, 当然是 (n + 1) 段啦. 另一个稍有难度的题目是, 无限平面上有n条直线, 问这些直线至多能把平面分成多少份? 在平面上画啊画就能归纳出解来的. 那么, 用 n 个平面, 最多能将无限三维空间划分成几个部分呢? 这个就略复杂了, 难道先建个 3D 模型, 然后归纳? 这个方法可行, 不过太浪漫和浪费了. 另外, 如果这个问题开始讨论维度更高的情形, 这种方法就行不通了. 那么, 问题来了: 使用 n 个 d 维 "*平整*" 的几何体, 来对无限 (d + 1) 维空间进行划分, 最多可以得到多少个部分? 不知道这个问题是否有官方名称了, 暂时称之为划分问题吧. 在这里, "平整" 指的是在该维度的空间中, 这些几何体的方程应该是线性的, 比如在 3 维空间中, 平面方程都可以表示为线性方程组 { $A_1 * x + B_1 * y = C_1$; $A_2 * x + B_2 * y = C_2$ }, 而在 1 维空间中的点就比较惨了, 就是 x = C, 不过还算是线性的. 其实大家只要有个基本的认识就行了, 不必这么刻板深究, 这篇文章中介绍的方法是没有严格证明的, 只是说说思路. 对能够画出来的各种维度进行一下归纳, 可以发现这样一个规律, 最开始开始的几次, 划分得到的空间区域是指数增长的: - 1 点分直线可以把直线分为 2 份
- 1 直线分平面可以把平面分为 2 份, 2直线分平面可以把平面分为 4 份
- 1 平面分空间可以把空间分为 2 份, 2平面分空间可以把空间分为 4 份, 3 平面分空间
可以把空间分为 8 份 这些规律可以*不完全归纳*假设为: n 个 d 维平整无限体分 (d + 1) 维无限体, 当 $n <= d$ 时, 可以分为 $2^n$ 份. 此外, 已知的结论有: - n 个点分直线至多将直线分为 (n + 1) 份;
- n 条直线分平面至多将平面分为 ($(n^2) / 2 + n / 2 + 1$) 份;
- n 个平面分空间至多将空间分为 ($(n^3) / 6 + 5 * n / 6 + 1$) 份;
所以再*不完全归纳*假设: n 个 d 维平整无限体分 (d + 1) 维无限体, 得到的份数 m 是 n 的一个幂多项式, 最高次项次数为 (d + 1). 由这些假设, 划分问题将可以用非常暴力的代数手段来解. n 个 d 维平整无限体分 (d + 1) 维无限体, 分得的空间数目 m 满足: $ m = a_d * n^(d+1) + a_(d-1) * n^d + ... + a_0 这里 $a_x$ 是该多项式的系数. 现在代入 (n, m) = {(0, 1), (1, 2), ..., (d, $2^d$)}, 得到一个 (d + 1) 元一次方程, 这样就可以唯一地解出 $a_d$, $a_(d-1)$, ..., $a_0$ 这 (d + 1) 个系数. 类似的 (未经证明的) 方法同样可以用来连续自然数幂求和问题: 对于自然数 m 和给定的自然数 n, 求通项公式 $ a(m) = 0^n + 1^n + 2^n + ... + m^n 同样, 设出通项公式方程 (注: 没有常数项) $ a(m) = a_k * m^(k+1) + a_(k-1) * m^k + ... + a_0 * m 然后根据没有化简的普通方程, 代入 m = { 1, ..., k }, 计算出前 k 个 a(m) (这个过程会很痛苦), 然后代入通项公式解方程 (唔, 这会更痛苦). 当然这只是另一个替代方案而已. Bernoulli 对自然数幂和公式的也做过研究, 他的方式是递推的, 运动量没有这个暴力方法大.
Posted at Nov 29 2009 - 01:39:18
Permanent Link:
/p/45
Load full text
|
Post tags:
Algebra
Algorithm
Geometry
|
|
泛型编程中的策略类
在编译期想要组合策略, 除开人肉内联不算, 有很多方式. 比如弄很多很多的 bool 参数 template <bool AllowDuplicate, bool SortElements, bool CheckOutOfRange>
struct just_another_container;
这看起来就是一个参数灾难, 如果某个地方出点小的模板编译错误, 哼哼~ 当然, 另一种简单的替代方案就是把所有的 bool 整合在一起, 形成一个位段 template <unsigned Policy>
struct just_another_container;
这种情况实际上缺点更多, 比如维护位域会很麻烦, 有可能在这个声明之前有这些枚举 enum {
ALLOW_DUP_MASK = 1,
SORT_ELE_MASK = 2,
CHECK_OUT_OF_RANGE_MASK = 4,
};
考虑这个容器有个 insert 函数, 它很可能需要考虑是否允许重复元素 template <unsigned AllowDuplicate>
void insert(element_type e);
而令人郁闷的是, 在 C++ 中不允许给函数偏特化, 也就是说这样写 template <>
void insert<0>(element_type e);
template <>
void insert<ALLOW_DUP_MASK>(element_type e);
是无法编译的! 要绕过这道坎, 得把 insert 函数放入一个模板结构体 template <unsigned AllowDuplicate> struct insert_s;
template <>
struct insert_s<ALLOW_DUP_MASK>
{
static void insert(just_a_container& container, element_type& e);
};
这样做代价高昂, 首先, insert 被当作孤儿一样的抛弃, 那么类中的任何非 public 成员都不再对它开放, 当然, 为了这么个简单的小玩意儿声明 friend 也是可行的, 但是多了不觉得烦吗? 另外, 在调用策略行为进行特化时一般只针对特定的位, 那么将该策略位从组合策略中分离出来, 代码中将充斥着这样的运算 Policy & ALLOW_DUP_MASK
Policy & CHECK_OUT_OF_RANGE_MASK
void another_member_function()
{
element_type ele;
// wanna call insert function of policy = Policy
insert_s<*Policy & ALLOW_DUP_MASK*>::insert(*this, ele);
// ...
}
这样做非常麻烦, 如果某个地方漏了 & 或者跟错误的掩码进行了运算, 哼哼~ 不过, 泛型程序设计有自己的方法, 那就是, 多继承! 不要吓到了, 是的, 在 C++ 远古时代, 多继承被认定为獠牙猛兽. 不过那都是跟 C++ 运行时多态相关的. 步入泛型新纪元的 C++ 又迎来了多继承第二春, 它可以显著改善上述问题. 将上面的声明编程 template <*typename Policy*>
struct just_another_container;
struct policy_base {};
struct allow_dup : public policy_base {};
struct sort_ele : public policy_base {};
struct check_out_of_range : public policy_base {};
组合策略, 只需要声明一个策略类型继承想要的策略, 并把它传入容器就能达到目的, 比如
Posted at Nov 22 2009 - 08:56:30
Permanent Link:
/p/36
Load full text
|
Post tags:
Generic Programming
C++
Template
|
|
闰年判定
Posted at Nov 17 2009 - 00:33:38
Permanent Link:
/p/25
Load full text
|
Post tags:
Algorithm
|
|
已知两圆圆心坐标及半径求两圆交点
在一个二维平面上给定两个圆的圆心横纵坐标、半径共 6 个参数, 求交点. 即实现下面的 C 函数 int intersect(struct circle_t const circles[], struct point_t intersections[]);
其中 point_t 与 circle_t 的定义分别是 Code Snippet 0-0
struct point_t {
double x;
double y;
};
struct circle_t {
point_t center;
double r;
};
函数 intersect 的输入参数为两个圆, 返回交点个数, 另外, 交点详细信息将被存入另一个参数数组 intersections 中. 由于两个圆之多有 2 个交点, 因此该函数可以如下形式调用: Code Snippet 0-1
#include <stdio.h>
int main(void)
{
struct circle_t circles[2];
struct point_t points[2];
/* 从 stdin 输入圆参数
* 按照如下格式
* $(x_0, y_0, r_0)$
* $(x_1, y_1, r_1)$
*/
scanf("%lf%lf%lf%lf%lf%lf",
&circles[0].center.x, &circles[0].center.y, &circles[0].r,
&circles[1].center.x, &circles[1].center.y, &circles[1].r);
// 如果两个圆相同
// *注意:* 由于 x, y, r 都是浮点数, 使用 == 进行判同可能导致问题
// 作为示例代码还是姑且这么写了
if (circles[0].center.x == circles[1].center.x
&& circles[0].center.y == circles[1].center.y
&& circles[0].r == circles[1].r)
{
puts("The circles are the same.");
return 0;
}
switch (*intersect(circles, points)*) {
case 0:
puts("No intersection.");
break;
case 1:
printf("(%.3lf %.3lf)n", points[0].x, points[0].y);
break;
case 2:
printf("(%.3lf %.3lf) (%.3lf %.3lf)n",
points[0].x, points[0].y,
points[1].x, points[1].y);
}
return 0;
}
用程序实现求交点方法可以有多种, 比较极端的甚至可以用到二分逼近, 反正计算机的计算能力跟笔算是两个世界; 不过本文还是老实一点, 仍试着来解方程. 在求解过程中, 除了用到圆的标准方程 $ (x - x_0)^2 + (y - y_0)^2 = r_0^2 (其中 $(x_0, y_0)$ 是其中一个圆的圆心, $r_0$ 是其半径; 当然对另一圆也是如此, 此处省略之) 圆的参数方程也将会被用到 现在, 设其中其中至少有一个交点 (没有交点的情况可以简单利用圆心距大于半径之和来判定), 换言之存在某个 $A_s$ 使得存在对应的点 $(x_s, y_s)$ 于两个圆的方程都成立, 即
Posted at Nov 15 2009 - 14:56:09
Permanent Link:
/p/14
Load full text
|
Post tags:
Algorithm
C
Geometry
|
|
0
1
2
3
4
5
6
7
8
9
10
Page 11
12
|
