用 Google 日历很多年,但却一直没有体会到 Google Calendar 的精髓,最近在使用过程中越来越得心应手,原因是结合手机的通知栏,能够非常方便的提醒日程。而 Google Calendar 在安排日程之外很棒的一点就是能够共享日历,不管是小到自己的行程安排,再到团队的时间规划安排,再大到一个国家的节假日都能非常轻松的分享出去。
早之前就已经添加了 中国的节假日日历,还有历史上的今天一些有趣的日历,这里就做个总结,在默认情况下 Google Calendar 在左边侧边会有一项 添加日历,在菜单中可以选择 “Browse calendars of interest” 然后在 Google 提供的清单中能够轻松的找到 “宗教日历”,包括 Christian,Jewish,Muslim,Orthodox 的日历,然后还有基于地区的日历,其中包括世界上很多国家的节假日日历,另外还有体育运动的日历,包括篮球、橄榄球、英式足球等各种赛事分类,甚至还有月相(Phases of the Moon) 的日历。简单的勾选即可添加到日历中。
比如说:
其实仔细观察一下就能发现这些日历的 ID,都是语言加上地区,比如说 zh-cn.china#holiday
,zh_cn.china#holiday
表示的就是中文显示中国的节假日,而 en.china#holiday
就表示英文显示中国的假日。
不得不说,其实已经不用添加农历日历了,Google Calendar 已经默认自带了农历,并且和整体搭配非常美观。在设置中,“视图选项”,其中有其他日历选项,选择中文简体,那么就会添加农历日历到界面中。
一个综合型日历分享网站
萨勒姆的女巫
朋友邀请,去北影看了场话剧—-萨勒姆的女巫—-原本对话剧并不了解,最开始了解话剧也才是从《夏洛特烦恼》主演开心麻花,而对于话剧的概念只停留在了电影电视剧的创作中。话剧的表演确实于电影电视剧作品不同,我要刷新一下我的世界观。原来我错过了世界上很多美好的东西,而我却不知道。
原剧本为,亚瑟 米勒 1953年剧本,四幕剧。该剧于1953年1月22日于百老汇的贝克剧院首次演出。之后成为了话剧经典。
小说原标题为 坩埚 “Crucible”,金属容器,可以将金属或者其他物质放入其中高温加热。剧中每个角色隐喻某种金属,接受着周围环境高温的考验。那些拥有超越死亡的道德人物,例如 约翰 普罗克托 和 瑞贝卡 寓指拒绝融化的物质。
帕里斯 牧师
艾比 帕里斯侄女
蒂图巴 Tituba
约翰 普罗克托 John Proctor 率直正直的农场主,剧本的绝对男主
伊丽莎白 普罗克托 John妻子
黑尔 牧师
托马斯帕特南 想要占领别人的土地
安 帕特南 托马斯的妻子,怀孕8次,流产7次
几个想留住的画面:
开场时全员亮相的时候,开场时虽然有一些恐怖,但开场幽灵似得全员亮相震慑住了我。
第二幕家中的对白,虽平淡,故事也很悲伤,但画面却很美好。
第四幕开场伊丽莎白从台阶上出场,画面太美了。
约翰和伊丽莎白的告别戏,将矛盾与个人命运推向高潮,命运的选择只在一瞬间。
很可惜的是这些画面并没有全部留下成为影像,观看的时候,我更愿意融入剧情而不愿意跳脱出来拿起相机。最后只从朋友那边盗来一些影像,不过我个人更加愿意将这些画面留在脑海。
在第一幕,最开始以为 帕里斯牧师 是非常正直的人物形象,而到后面几幕中形象大转变,从收受房契,到金子做的烛台,人物形象一落万丈。而同样人物形象转变的还有黑尔牧师,本来善良正直的牧师,到后来只能堕落颓废到劝说人们认罪。同样帕特南无理指控别人想要强行占他人领土地等等。人物形象的转变和刻画推动着剧情的发展。
而从第二幕开始约翰和伊丽莎白的戏开始,我才渐渐的进入剧情的设定,或者说,到第二幕的时候所有的背景故事,背景人物都才有所交代,故事才得以铺展开来。而第二幕过后剧情渐渐走向高潮,第三幕的审判,引入法官,将矛盾凸显,再到第四幕约翰伊丽莎白以及观众感到深深的绝望,将故事推向结局。
剧情中,几乎每个人的形象都刻画的比较生动。反派为各自的私心陷害别人,受到奴隶遭遇的女孩们的反抗,帕特南为夺取地产而进行的无理指控,而身为牧师的帕里斯为个人的私欲利用人们对上帝的信仰收敛钱财。(这里让我想到了那部印度电影《我个神啊》)而正面的角色,约翰虽然诚实正直,却也背叛了妻子,犯有奸淫罪,在为人上略有瑕疵,一直理性的黑尔牧师也在最后一幕变成了说服别人认罪的绝望者,而 伊丽莎白 为了拯救自己的丈夫,无奈得在法庭上作出了谎言。人人都在萨勒姆这样的炼狱中遭受折磨。
在真正的压抑和悲伤中让剧情达到高潮,然后结束整个舞台,才是真正好的剧本。
对于表演真是,没办法说,就像之前一位同学和我说的一样,无论是电影还是话剧等等的剧情和表演中,在第一遍观看的时候总是让人无法集中到演员的表演上。我在看话剧的时候,第一二幕基本将注意力放到了剧情上,记忆剧情中人物的名字和相貌,整理故事中发生主角的关系,了解故事发生的地点和背景。直到第二幕过后才渐渐的融入到故事的本身。哎,真应该在事前就做一下功课的,不然观看太累太累。当然没有做事前功课也带来另外的好处,也就是剧情发展无法预料到,只有真正到黑幕降下才能知道最后的结局。有的时候心中会设定一个剧情,就像最后我会希望那些女孩会为自己的说谎和无理指控而受到惩罚,而约翰和伊丽莎白会被判为无罪,而这其实都是无力的空想,如果剧作真的做了此结局那就落入了俗套。
关于表演,第一幕中的帕里斯牧师和艾比的表演,后几幕中约翰和妻子的表演都让我印象深刻。其实个人最初的时候最喜欢帕里斯牧师的表演,但是在后来剧情的推进中帕里斯牧师渐渐地走向反面,对角色的厌恶消弱了帕里斯的表演。自第二幕起就喜欢上了约翰和伊丽莎白,就个人偏好来说,其实更加喜欢伊丽莎白平铺的对白,没有约翰激动时口喷唾沫,也没有艾比陷害别人时的高声呐喊,伊丽莎白的表演最能让我感受到自然。虽然伊丽莎白在剧中不是唯一女主,剧情扮演上分量适中,但是其诚实正直的基督徒形象让人无法忘却。
或许我们在评价一个角色表演的时候经常带入角色形象,观众永远只会喜欢剧中的正面角色,从而忽略反派角色,而事实上此剧的艾比和蒂图巴 这两个反面的角色表演同样精彩,hen 同样在第三幕出现的审判长,出现再对立面,而我却无法喜欢上他,或许是因为对长官的天然敌意,亦或许是对审判长审判的公平性的质疑,总之无法让我公正地去评价他的形象。
类Unix系统下最棒的gif录屏应用—- byzanz record 。可能大部分的人会在需要用到gif时,会先用录屏软件将需要截取的内容录成视频,然后用 ffmpeg 或者其他的应用将视频转成 gif 动画。而这样会产生几个问题:
convert
优化,大小依然不乐观。而现在要介绍的 byzanz-record 就是一个轻量级的直接录屏产生 gif 的应用。Byzanz 可以直接避免以上两个问题,将录屏这件事情变得非常容易。看Debian package上面的介绍:
Byzanz is a desktop recorder and command line tool allowing you to record your current desktop or parts of it to an animated GIF, Ogg Theora, Flash or WebM. This is especially useful for publishing on the web.
Byzanz also allows recording of audio, when the output format supports it.
上面的介绍能够看到 Byzanz 的主要功能,同时说了支持的格式 GIF, Ogg Theora, Flash 和 WebM。同时使用的情况就是想要将内容发布到互联网上的时候。如果输出文件支持音频 Byzanz 也支持。
有维护者将 Debian 的代码移植到 PPA,这样我们可以通过 PPA 来安装使用,打开终端,输入以下内容安装:
sudo add-apt-repository ppa:fossfreedom/byzanz
sudo apt-get update && sudo apt-get install byzanz
如果 Ubuntu 14.04 和以上版本,直接使用:
sudo apt-get install byzanz
安装完毕之后可以在终端使用如下命名来熟悉使用 Byzanz:
byzanz-record --duration=10 --x=100 --y=200 --width=700 --height=400 out.gif
通过参数名字能够非常容易的知道含义,duration
就是时长,x
和 y
就是坐标,截取画面左上角的值,width
和 height
就是截取画面的寛和高,也就是画面的大小,最后就是输出文件的名字。
到现在可能有人发现 Byzanz 比较麻烦的地方了,有的时候我不知道要截取的目标的屏幕坐标和大小的时候呢,有的时候只想截取屏幕的某一个部分呢,如果只想录制一个窗口呢?
于是有人写了三个shell脚本文件:
byzanz-record-window
选择一个窗口录制byzanz-record-region
选择部分窗口录制下面分别介绍这三个脚本使用,分别将这些脚本保存到本地,赋予执行权限 chmod +x filename
,如果想要在终端任何地方使用,加入 $PATH
系统环境变量。
下载脚本,加入 $PATH
,使用例子:
byzanz-record-window 30 -c output.gif
$DELAY
变量设置)-c
参数表示byzanz将录制鼠标。
需要依赖: xrectsel
link. 使用 make
命令编译获取可执行的二进制。更多的配置参考项目文件。
使用详情参考上一个 section。
脚本由MHC提供。修改了以上脚本,做出了一个简单的GUI版本。
长达30s钟的gif,而文件大小只有3.5M,对于Web使用来说这是非常可喜的一个大小。而对于10s左右的动画,几乎1M左右的大小,让我感到非常的震惊。
下面就是30s的gif,画质虽然损失较大,但是完全不影响观感。
在我的 https://github.com/einverne/dotfiles 项目中有自动安装 byzanz 的脚本,一键安装然后使用即可。
年初的时候定下计划2015年一年至少阅读20本书,不管是小说还是专业书,现在离2015结束只有短短几天时间了,就梳理一下看过的书好了,顺带检查一下是否完成了任务。可惜结果很令我伤心。满心以为今年能读20本书,最后满打满算也只算读了16本书。今年欠了4本的债,明年2016年期望自己能够看下24本书吧。
看完电影之后还是不过瘾,于是乎补完小说。小说比电影更加精彩,电影因为时长的原因做了很多删减和改编,看小说更能体会到那种在绝境中想要生存下去的力量。
小说摘录
舍友推荐,舍友因为是英语文学专业,推荐的这本黑色预言式的小说非常的赞,小说对人性的刻画实在是不能让人忘记。这本小说更让我认识了威廉·戈尔丁,英国很著名的小说家。这部小说主要讲述的就是因为战争流失到荒岛的一群小孩,因为利益形成各自集团,之间发生的冲突与矛盾。
摘录
乔治奥威尔 反乌托邦小说,很早以前就想看不过没有坚持下来,今年总算是看完了。然后摘录一些警句。
约翰密尔,其实是很薄的书,因为当时英语课做presentation查资料找到,所以一直保存在待看列表。
全书要义可以概括为两条基本原则:
摘录
快乐学哲学 英语课课程材料,通俗易懂的语言介绍西方哲学。推荐看英文原版。
学习bash 今年系统的学习一下Linux,但Linux体系太复杂,先从bash看起。
更加详细一点的bash教程
参考bash 学习笔记.
很经典,很详细,却也略显啰嗦的Linux入门书
笔记可以参考 linux 学习笔记
因项目需要C++,Python的结合,看了boost.python部分,后来又自学了boost中的property_tree用来解析json。其他部分未详细看,只大略扫过。
学期中做了个讲座,大略的看了一些知识,Git实在强大,很多特性到现在我也没搞懂。这书要一直备着。
笔记参考git 学习笔记
只学了个大概,因为平时用C++多。
年初的时候读的,似乎已经忘得差不多了,总之“大数据”很玄乎。
剧本结构设计 忘记了什么时候200-100的时候买的了,喜欢看电影,而我们总是谈论到剧情设计,于是就买了一本看。
一直订阅着这位作者的博客,看完这本书之后就全面使用Evernote中,放弃了OneNote,和Google Keep
摘录
在观看纪录片《操作系统革命》中提到的这本书的作者,正好实验室有这本书,就拿了看了。这本书主要将软件开发的两大方式,正如书名所述,一种是公司内部集中式的开发,另外一种就是类似 GitHub 上那种分工合作式开发。这两者各有利弊,但作者作为 GNU 的倡导者必然是支持开源的。
别告诉我你会记笔记 学会记笔记是很重要的事情。
摘录
看到最后一句话其实感触挺大,回想起 Google Reader 关闭,这真是 Google 做出的很差的一件事情。Reader 中的东西都曾经是阅读过,甚至做过笔记的东西,那也就是自己的东西,再怎么使用 Google 搜索,出来的东西也都不是自己的经验。所以现在我也在培养我隔断时间总结上一阶段的习惯,这样自己总结,自己写下来的东西才真正属于自己。
期待2016年美好的开始。
很久没有看到这样反正真实中国的电影了,近两年的国产电影不是被早恋打胎的青春片,就是被各种古怪离奇的古装片,在就是无厘头的喜剧片所霸占。幸而有这样一部电影能够让2015年的国产电影画上一个稍稍圆满的句号。
剧情上,这样一部电影融入了太多真实的新闻,以至于会让人一一和某某事件联系上,人们往往说,电影往往是现实的表现。而这样一部老炮儿正是在真实这件事情上花了太多的功夫。从老北京的腔调到巷口胡同,从酒吧夜宿到马路飙车,从故友借钱到朋友援手,一件一件的小事敲打着人们的心,虽然故事发生在北京,虽然故事的主人公有着特殊的经历,可正是从这样的角度让我们看到了现代人们的人情冷漠,看到了整个中国的一个缩影,城管会不顾形象的殴打底层的百姓,匆匆的行人不会停下匆忙的脚步帮助路边无助的少女,甚至在看到别人跳楼时无情的煽动,更甚至于几十年的友情会在金钱面前变得一文不值。电影中的情节虽是虚构,却真实的让人发抖。电影看至一半就无法忍住打转的眼泪,同情六爷以及他的遭遇,为六爷的仁义感动。我们的社会正迈向黑暗,却少有六爷这样的人出面维护。为何我们会不相信路边求助的少女?为何我们不敢搀扶跌倒的老人?为何我们的眼里只有金钱?是我们少了什么东西吗?是我们被欺骗多次吗?亦或是像电影中说得那样“现在的人们,遇事都躲”。越来越多的人都不讲理,不讲规矩。往小了说就是百姓的日常百态,而往大了说就是三环十二少无法无天,在大就是他爹千万的账单。社会越来越没有理,越来越混乱,而这也仅仅是电影所表现出来的一部分而已。
在说到剧本设计上面,到现在很少的国产电影能够做到情节上的呼应,很多的时候就是主角想要做什么就凭空能够出现什么,而老炮儿在这方面做的非常的棒。现在能够列举的很多情节在前后发展中都能找打影子,六爷用报纸裹挟遗物扔到理发店呼应话匣子在理发店发现用报纸卷着的房产证,六爷心脏病发作呼应早先话匣子一直说心脏的问题,六爷在路边给建工女孩200元钱呼应片末女孩从远方寄来的挂号信,六爷在片尾穿军大衣用日本军刀独自约架呼应儿子和话匣子对话中对六爷十几年前一人单挑十几人的回忆。这样的剧本设计无意让故事的说服力大大增强。电影虽然有很多未交待的事情,但也正是因为这样才造就一部好电影的剧情。一部好电影就应该是将故事的一个切片展现给人们看,甚至能让人们产生就是电影结束了故事还在继续的错觉。如果真能做到那样,这样的电影离佳片也就不远了。而老炮儿正是这样一部电影,剧情没有交代六爷的妻子,也没有交代六爷故友的生活种种,同样也没有交代三环十二少,但是通过一些侧面的描述,通过电影的叙事交代,电影想要讲述的故事是完整的,那就够了。
不得不说的冯小刚表演,早在电影上映之前就被无数的消息所报道,冯小刚凭借此片获得了金马影帝。一直很想看一看一个导演的表演功力,但是不得不说我被冯小刚的演技震撼到失语。可能原先还有一丝的“嘲讽”,只刚刚开头的城管戏,就让我对冯小刚刮目相看。以至于到最后和三环十二少演对手戏,再到拜访故人借钱救子,一丝一毫的表情动作,刷新了我对冯小刚的认识。片中饰演的六爷有着无比庞大的气场,平时看只是胡同巷子里面普普通通的市井小民,而一旦遇事,六爷凭借自己地位打抱不平,用“规矩”解决所有事情。
六爷的几场戏深深的印在了我的脑海里,一是开场和城管的戏,再就是到修车厂和三环十二少的戏,再到朋友(洋火儿)家借钱,到最后颐和园后野湖。每一个和冯小刚演对手戏的演员,无不给冯小刚的气场所压倒。
而其他的表演也就不想说什么了,这部电影只需要看冯小刚一个人演就够了,而六爷身边的一身肌肉的闷三儿(张涵予),无时不刻不在帮助六爷的话匣子(许晴),还有老实憨厚的灯罩儿,他们都个性十足,表演也到没有太大的瑕疵。尤其是闷三儿在修车厂,还有六爷被打闷三儿带领一帮人砸修车厂的几个镜头让张涵予非常帅气。只是在六爷面前就显得弱很多了。
因此最后在剧本上给7.5分,表演给8分,娱乐性思考性给8分。
观影风向标做了一期引进片的排名,我顺便也简单地回忆了一下。然后根据2015年引进片豆列,找出了10部我非常喜欢的引进片。
就像观影风向标中所说,每个人都有一个自己的排名,没有最终的标准答案,每个人都有自己的喜好,不需要迁就谁,喜欢就好。
当之无愧的年度最佳—-王牌特工:特工学院 2015-04-19,记得这部电影上映的时候并不是很了解,只是之后听了节目并看到一些影评觉得非常值得一看,在最后快下线的时候找了很远的一家影院看了。虽然当时同去的朋友对最后脑袋放烟花的镜头颇有微词,但是依然不减这部电影的魅力,我最喜欢的几大类电影中特工片一直靠前。而自从谍影重重马特达蒙不在参演,碟中谍系列,007系列偏离出我的口味稍远之后,很久没有看到一部对胃口的特工片了。不过很遗憾的是国内上映版的阉割。
年度最佳科幻—-火星救援 2015-11-25,如果说2014年的星际穿越让我开始重拾起对宇宙的兴趣,那么这一部火星救援让我重拾起了对科幻片的兴趣。演员上有我很喜欢的马特达蒙,还有很多很多熟悉的脸孔,故事情节上有我喜欢的火星宇宙题材,这样一部电影如何能让我忘记。
模仿游戏 2015-02-19,虽然是一部去年的电影,但是要是放到今年依然是一部非常棒的传记类电影,先不说图灵在计算机界的名声和地位,就卷福的生动表演也能让这部电影出彩。
最佳动画—-头脑特工队 2015-11-01,天马行空的想象力,虽然说不上什么道理却非常有说服力的情节设定,以及让我找回的那份童真,无疑让这部电影在我这里的得分要高于大白 (●—●),说到超能陆战队,当然也是很不错的一部电影,剧本,情节设计毫无问题,只是我觉得过于好莱坞流水线产品,我在年初的时候就看完了这部片子,那时候这部片子还没有在国内上映,而过了一些时候之后,突然满大街,身边大家都在说着大白,我其实有些疑惑,后来才发现是因为国内上了,然后布天盖地的宣传,其实我不太明白是因为宣传造就了这部电影还是因为其他。
我的个神啊 PK 2015-05-29,宗教题材的电影,观影风向标中波米总结的很好,这样一部电影有着自己的底线,没有否定宗教,也没有否定信仰,只是否定了打着宗教信仰招摇撞骗的神棍。这样一部电影在我们这样一个无神论的国家里,没有批判什么,但是身边的好多人却都以为这样的一部电影是反宗教的,真是太天真。
前目的地 2014-12-04,虽然在14年年末的时候已经看了,看到时候甚至一度以为是一部超级烂的电影,因为剧情设定在前半段时间推进太缓慢,在酒店叙事那一段差点让我睡着,但是之后的剧情发展让我深深的膜拜这部电影。
超能查派 2015-05-21,个人很喜欢的电影,一直对机器,人性很感兴趣,导演很聪明,将机器人形容成新生的婴儿,他的成长环境决定了机器人的人格,他的是非判断基于他所学习到的东西,而这不正也是一个人之所以为为一个人的基本常识吗?我们如何做一个判断?无非也就是从生活经历或听,或读,或看到的来下决定。当然这样一部电影,有主题,有思想,有特效,对我来说也就够了。
碟中谍5:神秘国度 2015-09-13 之前也提到过碟中谍系列的特工片一直是很喜欢的系列,当然这一部也差,只是相较其他传达思考的电影来说,这真是纯粹的爆米花电影了。
速度与激情7 2015-04-12 话题大片啦,加上保罗沃克的离世,加上片尾的煽情歌曲,这样一部有剧情,有动作,有视效的大片总有其一席之位。
歌曲改变人生 Begin Again 2014-12-01 舍友推荐,虽然去年年末已看过,放到今年这样一部音乐类电影依然给我非常棒的感觉。
极速风流 Rush
两年前的片子,如果不听节目真的不知道这样一部电影。
思悼
年末的时候不止一遍的在各种榜单上看过,总之有其上榜的理由吧。
小王子
准备看小说,然后再补一下好了。
早晨 初雪
中午 披萨
中午 火锅
饭后
人生如此夫复何求。
对应书中第三章 内存管理,着重讲 boost 实现的智能指针,和内存池pool 等概念。众所周知,C++没有提供Java中的垃圾回收机制,因此 boost 实现智能指针用来管理内存避免一些问题。C++继承 C 高效灵活地指针,但是同样带了了很多问题:
虽然STL提供了 auto_ptr
,但是受限太多(不能放到容器中,因为不支持拷贝构造函数和赋值),因此很少有人使用。
智能指针(smart_ptr
)是Boost各组件中,应用最为广泛的一个。使用智能指针需包含以下头文件,如果只使用智能指针 shared_ptr 可以只包含同名头文件。
#include <boost/smart_ptr.hpp>
using namespace boost;
Boost从很早就提供了如下的智能指针,并且功能一直保持稳定:
有其他任何问题,请查阅官方文档: http://www.boost.org/doc/libs/1_60_0/libs/smart_ptr/smart_ptr.htm
从名字就可以看出,这种智能指针只限于作用域内使用,无法转移内置指针的管理权(不支持拷贝、=赋值等) 但是作用也很显然,例如:
void test()
{
int* p = new int(3);
...
delete p;
}
假设定义到delete之中…发生了异常,那么p就无法被delete,造成了内存泄漏。使用scoped_ptr就可以很好解决这个问题,只需要new的时候放到scoped_ptr之中就可以了。
scoped_ptr 常用方法:
假设:
scoped_ptr<T> ptr_t(new T); // 假设内置指针为p_t
则:
例子:
// scoped_ptr usage
scoped_ptr<string> sp(new string("text"));
cout << *sp << endl;
cout << sp->size() << endl;
// pointer 管理权移交 scoped_ptr
auto_ptr<int> ap(new int(10));
scoped_ptr<int> scoped(ap);
assert(ap.get() == 0);
ap.reset(new int(20));
cout << *ap << ", " << *scoped << endl;
auto_ptr<int> ap2;
ap2 = ap;
assert(ap.get() == 0); // ap is null-pointer
具体例子如下:
#include <iostream>
#include <boost/smart_ptr.hpp>
class SmallClass
{
public:
SmallClass(int x_val)
{
x = x_val;
std::cout << "SmallClass construct " << x << std::endl;
}
virtual ~SmallClass()
{
std::cout << "SmallClass destory " << x << std::endl;
}
int GetX()
{
return x;
}
private:
int x;
};
int main()
{
std::cout << "main start" << std::endl;
// scoped_ptr on basic
boost::scoped_ptr<int> int_ptr(new int);
*int_ptr = 100;
++*int_ptr;
std::cout << *int_ptr << std::endl;
// scoped_ptr on class
boost::scoped_ptr<SmallClass> sc_ptr(new SmallClass(0));
std::cout << sc_ptr->GetX() << std::endl;
sc_ptr.reset();
std::cout << "main end" << std::endl;
return 0;
}
同 scoped_ptr 基本一样,只不过可接受数组的new [],多了下标访问操作,其他类似。
scoped_array 轻巧方便,没有给程序增加额外负担,但是 scoped_array 功能有限,不能动态增长,也没有迭代器支持,不能搭配 STL 算法,仅有一个纯粹的“裸”数组接口。在需要动态数组的情况下我们应该使用 std::vector 。
例子如下:
#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;
int main(int argc, const char * argv[]) {
scoped_array<int> scopedarr(new int[100]);
scopedarr[0] = 100; // 赋值
// *(scopedarr+1) = 200; // error
// fill array with 100 value 2
fill_n(&scopedarr[0], 100, 2);
cout << scopedarr[2] << endl;
scopedarr[3] = scopedarr[0]+scopedarr[1];
cout << scopedarr[3] << endl;
cout << scopedarr.get()[3] << endl;
return 0;
}
最像指针的“智能指针”,是 boost.smart_ptr 库中最有价值,最重要的组成部分。支持拷贝构造函数、支持赋值操作。重载了*和->操作符用来模仿原始指针的行为。目前已成为tr1标准的一部分,发展自原始的auto_ptr,内置引用计数。
使用时候有3点要特别注意:
不要将shared_ptr用于函数的临时参数:
// 下面这个是OK的。
void ok()
{
shared_ptr
// 下面这个就可能内存泄漏!
void bad()
{
f(shared_ptr
看看基本的使用例子。
#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>
using namespace boost;
void print_count_func(shared_ptr<int> p){
std::cout << "cout: " << p.use_count() << " value= " << *p << std::endl;
}
class shared {
private:
shared_ptr<int> p;
public:
shared(shared_ptr<int> _p):p(_p) {}
void print(){
std::cout << "cout: " << p.use_count() << " value= " << *p << std::endl;
}
};
int main(int argc, const char * argv[]) {
// 构造函数
// 无参数构造空指针 shared_ptr
shared_ptr<int> p0;
// shared_ptr(Y * p) 获得指向类型 T 的指针 p 的管理权
shared_ptr<int> p1(new int);
*p1 = 12;
// shared_ptr(shared_ptr const & r) 从另外 shared_ptr 获取管理权,两个 shared_ptr 同时共享一个指针管理权
shared_ptr<int> p2(p1); // p1 引用计数加1
std::cout << "p1 count: " << p1.use_count() << " value: " << *p2 << std::endl;
*p2 = 13;
std::cout << "p1 count: " << p1.use_count() << " value: " << *p2 << std::endl;
p2.reset();
std::cout << "p1 count: " << p1.use_count() << std::endl;
// shared_ptr(std::auto_ptr<Y> & r) 从 auto_ptr 获得指针管理权, 同时 auto_ptr 失去管理权
std::auto_ptr<int> p;
shared_ptr<int> p3(p);
// operator= 赋值操作符,从另外一个 shared_ptr 或 auto_ptr 获得指针管理权,等同于构造函数
shared_ptr<int> p4 = p1;
// shared_ptr(Y * p, D d) 类似于 shared_ptr(Y * p)
// 第一个参数是要被管理的指针,第二个删除参数 d 告诉 shared_ptr 在析构时不使用 delete 来操作指针 p,而使用 d 来操作,把 delete p 换成 d(p)
// usage
shared_ptr<int> sp(new int(100));
print_count_func(sp);
shared shared1(sp), shared2(sp);
shared1.print();
shared2.print();
*sp = 200;
print_count_func(sp);
shared1.print();
// make_shared
// include <boost/make_shared.hpp>
shared_ptr<std::string> strp = make_shared<std::string>("make_test");
shared_ptr<std::vector<int> > vecp = make_shared< std::vector<int> >(10, 3);
std::cout << *strp << " " << vecp->size() << std::endl;
// shared_ptr in vector
// 因为 shared_ptr 实现了拷贝构造、=赋值构造等函数,因此可以完美的放入STL容器中。
typedef std::vector< shared_ptr<int> > vs;
vs v(10);
int i = 0;
for (vs::iterator pos = v.begin(); pos != v.end(); ++pos) {
*pos = make_shared<int>(++i);
std::cout << *(*pos) << ", ";
}
std::cout << std::endl;
shared_ptr<int> ptest = v[9];
*ptest = 100;
std::cout << *v[9] << std::endl;
return 0;
}
然后来讨论类中成员使用shared_ptr的例子,先扯一个稍微远一点的。假设我们类的成员需要new出来,先来看一个错误的例子:
#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>
using namespace boost;
class ClassOne
{
public:
ClassOne(int data_param):data(NULL)
{
init(data_param);
std::cout << "construct" << std::endl;
}
virtual ~ClassOne()
{
if(data)
{
delete data;
}
data = NULL;
}
void init(int data_param)
{
if(data)
{
delete data;
}
data = new int(data_param);
}
private:
int* data;
};
int main(int argc, const char * argv[]) {
ClassOne c1(10);
ClassOne c2(c1);
ClassOne c3 = c2;
return 0;
}
上面的ClassOne没有问题,但是会由编译器生成默认的拷贝、赋值构造函数,于是,当c3=c2或者c2(c1)时, 指针data的地址被复制了多份,c1、c2、c3各持有一份,析构的时候就被delete了3次,于是memory error是必须的了。遇到这种情况传统做法就是,c1、c2、c3各保存独立的data区域,即深拷贝:自己写拷贝构造、赋值构造函数。
#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>
using namespace boost;
class ClassOne
{
public:
ClassOne():data(NULL) {}
ClassOne(int data_param):data(NULL)
{
init(data_param);
std::cout << "construct" << std::endl;
}
virtual ~ClassOne()
{
if (data) {
delete data;
}
data = NULL;
}
ClassOne(const ClassOne& rhs){
std::cout<< "copy " <<std::endl;
data = NULL;
init(*rhs.data);
}
ClassOne& operator = (const ClassOne& rhs){
std::cout<< "assign " <<std::endl;
delete data; // delete your own old data
data = new int(*rhs.data); // clone the rhs's data
return *this;
}
void init(int data_param)
{
delete data;
data = new int(data_param);
}
private:
int* data;
};
int main(int argc, const char * argv[]) {
ClassOne c1(10);
ClassOne c2(c1); // 实际调用的是B(A)拷贝操作 call copy constructor
ClassOne c3;
c3 = c1; // 申明之后进行赋值运算 call assignment function
return 0;
}
现在我们假设另外一种情况,即data仍然需要从堆上new出来,但可以被若干实例共享。此时可以用 shared_ptr,而且甚至不需要编写拷贝构造、=赋值构造,就可以。如下:
#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>
using namespace boost;
class ClassOne
{
public:
ClassOne(int data_param):ptr_data(new int)
{
init(data_param);
std::cout << "construct" << std::endl;
}
virtual ~ClassOne()
{
}
int get_data() const{
return *ptr_data;
}
long ptr_count() const {
return ptr_data.use_count();
}
void init(int data_param)
{
*ptr_data = data_param;
}
private:
shared_ptr<int> ptr_data;
};
int main(int argc, const char * argv[]) {
ClassOne c1(10);
ClassOne c2(c1);
ClassOne c3 = c2;
std::cout << c1.ptr_count() << std::endl;
std::cout << c2.get_data() << std::endl;
return 0;
}
实际上,c++编译器自动生成的拷贝、=赋值构造函数完成了ptr_data的赋值拷贝工作,而智能指针赋值拷贝的同时,引用计数也加1了。在默认析构函数也是如此,析构函数执行之后,会调用所有成员(ptr_data)的析构函数,检查引用计数都为0后,会delete掉这个int。 从而完美的完成了无内存泄漏的、无内存出错的、多个实例之间的指针变量共享。
同scoped_array类似,shared_array是shared_ptr的数组版本,不再赘述。
weak_ptr 被设计为与 shared_ptr 共同工作,可以从一个 shared_ptr 或者另一个 weak_ptr 对象构造,获得资源的观测权。但是 weak_ptr 没有共享资源,它的构造不会引起指针引用计数的增加,同时,在析构的时候也不回引起引用计数的减少。
shared_ptr看起来已经很完美了,但有个致命缺陷:不能管理循环引用的对象。 看如下的例子:
#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
class parent;
class children;
typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;
class parent
{
public:
~parent() { std::cout <<"destroying parent\n"; }
public:
children_ptr children;
};
class children
{
public:
~children() { std::cout <<"destroying children\n"; }
public:
parent_ptr parent;
};
void test()
{
parent_ptr father(new parent());
children_ptr son(new children);
father->children = son;
son->parent = father;
}
void main()
{
std::cout<<"begin test...\n";
test();
std::cout<<"end test.\n";
}
由于parent和child相互引用,他们的计数永远都为1,所以这样使用shared_ptr必然会导致内存泄漏。 boost::weak_ptr必须从一个boost::share_ptr或另一个boost::weak_ptr转换而来,这也说明,进行该对象的内存管理的是那个强引用的boost::share_ptr。boost::weak_ptr只是提供了对管理对象的一个访问手段。 弱引用不更改引用计数,类似普通指针,只要把循环引用的一方使用弱引用,即可解除循环引用。 还有两个常用的功能函数:expired()用于检测所管理的对象是否已经释放;lock()用于获取所管理的对象的强引用指针。
class children
{
public:
~children() { std::cout <<"destroying children\n"; }
public:
boost::weak_ptr<parent> parent;
};
再次强调,weak_ptr必须从shared_ptr而来。
#include <boost/smart_ptr.hpp>
#include <iostream>
int main()
{
boost::shared_ptr<int> ptr(new int(10));
std::cout << ptr.use_count() << std::endl;
boost::weak_ptr<int> ptr_weak(ptr);
std::cout << ptr.use_count() << std::endl;
std::cout << ptr_weak.expired() << std::endl;
return 0;
}
intrusive_ptr是一种“侵入式”的引用计数指针,实际并不提供引用计数功能,而是要求被存储的对象自己实现引用计数功能。可以应用于以下两种情形:
date_time 日期相关的库,是 boost 中少数需要编译的库,但是实践中,在 Linker 链接器中链接 libboost_date_time.a
即可。也就是在链接时,加上 -l(boost_date_time) 参数。
使用 date_timer 需要包含以下头文件。 diedaiqi #include <boost/date_time/gregorian/gregorian.hpp> using namespace boost::gregorian;
将时间想象成无线延伸的实数轴,时间点是数轴上的一个点,时间段就是区间,时长是有正负号的标量,两个时间点差,不属于数轴。时间点,时间段,时长之间可以进行运算,有些有实际意义,例如时间点+时长=时间点,时长+时长=时长,时间段交集∩时间段=时间段,时间点属于∈时间段等等,有些无意义等等。
date_time 库支持无限时间和无效时间(NADT, Not Available Date Time)。
日期基于格里高利历,支持从 1400-01-01 到 9999-12-31 之间的日期计算,不支持公元前日期,名字空间 boost::gregorian, 需要包含上文所述头文件。
date 是 date_time 库处理日期的核心类,使用32位整数作为内部存储,以天位单位表示时间点概念,日期的构造方法
date d1; // 无效日期
date d2(2010,1,1);
date d3(2000, Jan, 1);
date d4(d2); // 拷贝构造
//you can compare between d1 d2 d3 d4 with == < >
也可以直接使用字符串来构造:
date d0 = from_string("1999-12-31");
date d5 ( from_string("2005/1/1") );
date d6 = from_undelimited_string("20001109");
或者直接从工厂类构造,调用 day_clock 的静态成员函数 local_day() 或者 universal_day() 返回当天的日期对象,分别是本地日期和 UTC 日期。 local_day() 依赖于操作系统时区设置。
// local date and UTC date
cout << day_clock::local_day() << endl;
cout << day_clock::universal_day() << endl;
特殊的日期:
date neg(neg_infin); //negative infinite time
date pos(pos_infin); //positive infinite time
date notdate(not_a_date_time); //not a date time
date maxdate(max_date_time); //max date
date mindate(min_date_time); //min date
cout << neg << endl << pos << endl << maxdate << endl << mindate <<endl;
date 成员函数 year(), month(), day() 返回年月日; year_month_day() 返回 date::ymd_type 结构,一次性获取年月日信息。
date nowdate = day_clock::local_day();
date::ymd_type ymd = nowdate.year_month_day();
cout << ymd.year << endl << ymd.month << endl << ymd.day << endl;
// day_of_week() return Monday, Tuesday..
// day_of_year() return number of the day in this year, max 366
// end_of_month() return the date of end of month
cout << nowdate.day_of_week() << endl;
cout << nowdate.day_of_year() << endl;
cout << nowdate.end_of_month() << endl;
day_of_week() 返回 date 星期数, 0 表示星期天; day_of_year() 返回 date 是当年第几天,最多366; end_of_month() 返回当月最后一天的 date 对象。
week_number() 返回date所在周是当年的第几个周,范围0到53. 如果年初的几天为去年的周,则周数为53,即第0周。
date 有5个 is_xxx() 函数,用于检验日期是否是一个特殊日期
date 对象转成字符串输出
date now = day_clock::local_day();
// date output
cout << to_simple_string(now) << endl; //YYYY-mmm-DD mmm English
cout << to_iso_string(now) << endl; //YYYYMMDD
cout << to_iso_extended_string(now) << endl; //YYYY-MM-DD
cout << now << endl;
支持流输入
date inputdate;
cout << "Input a date: "; // 2010-Jan-01
cin >> inputdate; //default using YYYY-mmm-DD English abbr
cout << "\nThe input date is: " << inputdate << endl;
日期长度类 date_duration , 天为单位,度量时间长度的标量。值为任意整数,可正可负。
成员函数 days() 返回时长天数, is_special() 和 is_negative() 可判断 date_duration 对象是否为特殊值,或者负值, unit() 返回时长最小单位,即1
date_duration 支持全序比较操作 ==, != , <, <= 等等,支持加减法,递增递减,支持除整数,其他乘法,取模,取余不支持。
date_time 库为 date_duration 定义了一个常用的 typedef:days 名字。
days dd1(10); // ten days
weeks w(2); // two weeks
months m(5); // five months
years y(2); // two years
months m2 = y + m; // two years and 5 months
日期支持简单加减运算
// date compute
date dstart(2000,1,1), dend(2008,8,8);
cout << dend - dstart << endl; // 3142 days
dstart += days(10); // 2000-1-11
dstart += months(2); // 2000-3-11
dstart -= weeks(1); // 2000-3-4
dstart += years(4); // 2004-3-4
//something need to be noticed
date endofmonth(2010, 3, 30);
endofmonth -= months(1); //2010-2-28
endofmonth -= months(1); //2010-1-31
endofmonth += months(2); //2010-3-31
date_period 类来表示日期区间,时间轴上是一个左闭右开区间,端点是两个date对象,左值必须小于右值。
// date period
date_period pd(dstart, dend); // (date, date)
date_period pd1(dstart, days(10)); // (date, days)
cout << pd << endl;
pd.shift(days(10)); // shift days 平移N天,长度不变
cout << pd << endl;
pd.expand(days(3)); // expand days 像两端扩展三天,长度加2n天
cout << pd << endl;
成员函数 begin() & end() 返回日期区间两个端点, end() 返回 last() 后的第一天。
date_period 可以全序比较运算,依据区间端点,即第一个区间的end() 和第二个区间的 begin(), 判断两个区间在时间轴上的位置大小。如果日期区间相交或者包含,比较操作无意义。
date_period 支持输入输出操作符,默认的输入输出格式是 YYYY-mmm-DD/YYYY-mmm-DD.
date date2014 = from_string("2014-01-01");
date nowdate = day_clock::local_day();
date_period pdl(date2014, nowdate);
date one_day_in_2015 = from_undelimited_string("20150101");
cout << pdl.contains(one_day_in_2015) << endl;
/*
* date_period
* is_before(), is_after()
* contains()
* intersects() 区间是否存在交集
* intersections() 返回两个区间的交集
* is_adjacent() 是否相邻
* merge() 返回两个区间并集,如果无交集或者不相邻则返回无效区间
* span() 合并两区间及两者间的间隔
*/
日期迭代器
/*
* date iterator
* use only ++iterator, --iterator, don't use iterator++, iterator--
*/
date d(2006,11,26);
day_iterator d_iter(d);
++d_iter;
year_iterator y_iter(d,3); // 增减步长为3年
++y_iter; // 增加3年
cout << y_iter->year();
void print_one_month(){
date nowdate = day_clock::local_day();
date month_start(nowdate.year(), nowdate.month(), 1);
date month_end = nowdate.end_of_month();
for(day_iterator d_iter(month_start); d_iter != month_end; ++d_iter){
cout << *d_iter << " " << d_iter->day_of_week() << "\t";
if(d_iter->day_of_week() == boost::date_time::Sunday){
cout << endl;
}
}
}
/*
* input your birthday and years after that output the day of
* future birthday
*/
void birthday_week(){
date birthday(1992, 06, 05);
years y30(30);
date future_birthday = birthday + y30;
cout << future_birthday.day_of_week() << endl;
}
/*
* printout the days passed since you were born.
*/
void days_passed(){
date birthday(1990, 10, 8);
date nowdate = day_clock::local_day();
cout << "Since you were born, there were " << nowdate - birthday << " days passed!"<< endl;
}
度量基本小时、分钟和秒钟,秒以下精确到微秒。
time_duration 有子类,度量不同时间分辨率,分别是: hours,minutes,seconds,millisec/milliseconds,microsec/microseconds和nanosec/nanoseconds。
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace boost::posix_time;
// 2 h 01 m 06.001 s
time_duration td(1, 60, 60, 1000*1000*6 + 1000);
hours h(1); // one hour
minutes m(10);
seconds s(30);
millisec ms(1);
time_duration td1 = h + m + s + ms;
time_duration td2 = duration_from_string("1:10:30:001");
cout << td2 << endl; // 01:10:30.001000
cout << to_simple_string(td1) << endl;
cout << to_iso_string(td2) << endl;
构造函数中同时指定date和time_duration对象,ptime等于一个日期加上当天的时间偏移,轻量级对象,可以被高效的任意拷贝和赋值,支持全序比较和加减运算。
using namespace boost::gregorian;
ptime p(date(2010,3,5), hours(1));
ptime p1 = time_from_string("2012-09-11 09:09:09");
cout << p1 << endl;
ptime p2 = from_iso_string("20100909T011001");
cout << p2 << endl;
ptime nowtime = second_clock::local_time(); // second accurate
ptime nowtime2 = microsec_clock::universal_time(); // milli second accurate
ptime pnot(not_a_date_time);
ptime pinf(pos_infin);
cout << to_simple_string(nowtime) << endl;
cout << to_iso_string(nowtime) << endl;
cout << to_iso_extended_string(nowtime) << endl;
time_period tp1(nowtime, hours(8)); // start from nowtime, last for eight hours
tp1.shift(hours(2));
tp1.expand(hours(1));
时间迭代器和日期迭代器,时间迭代器需要时间点和时间长度来构造。
ptime p(day_clock::local_day(),hours(10));
for (time_iterator t_iter(p, minutes(10)); t_iter < p+hours(1); ++ t_iter) {
cout << *t_iter << endl;
}
C++中操作时间的类。timer 是一个很小的库,提供简易的度量时间和进度显示的功能,可用于测试性能计时任务等大多数情况。timer 库包含三个组件, 计时器类 timer, progress_timer 和进度条指示类 progress_display。对应书中第二章内容。
timer 位于boost命名空间,需要包含头文件 <boost/timer.hpp> 即:
#include <boost/timer.hpp>
using namespace boost;
timer变量声明之后即开始计时工作,之后可以调用 elapsed()
方法来测量对象自创建之后所流逝的时间。成员函数 elapsed_max()
和 elapsed_min()
方法返回 timer 能够测量的时间最大值和最小值,输出单位秒。timer类的实现代码很少,可参考源码学习。
/**
* timer simple and useful, suitable for short time task.
* Do not use it to calculate time for long time.
* For long time calculate check date_time lib
*/
using boost::timer;
timer t; // declare timer start counting
cout << "max timespan:" << t.elapsed_max() / 3600 << "h" << endl;
cout << "min timespan:" << t.elapsed_min() << "s" << endl;
cout << "now time elapsed:" << t.elapsed() << "s" << endl;
使用标准库头文件
class timer
{
public:
timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
// timer( const timer& src ); // post: elapsed()==src.elapsed()
// ~timer(){}
// timer& operator=( const timer& src ); // post: elapsed()==src.elapsed()
void restart() { _start_time = std::clock(); } // post: elapsed()==0
double elapsed() const // return elapsed time in seconds
{ return double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
double elapsed_max() const // return estimated maximum value for elapsed()
// Portability warning: elapsed_max() may return too high a value on systems
// where std::clock_t overflows or resets at surprising values.
{
return (double((std::numeric_limits<std::clock_t>::max)())
- double(_start_time)) / double(CLOCKS_PER_SEC);
}
double elapsed_min() const // return minimum value for elapsed()
{ return double(1)/double(CLOCKS_PER_SEC); }
private:
std::clock_t _start_time;
}; // timer
#include <boost/progress.hpp>
using namespace boost;
在定义 progress_timer 之后,析构对象时会自动输出流逝时间。可以使用花括号,来使 progress_timer 实现计时功能。
progress_timer t;
// do some work
cout << t.elapsed() << endl; //print out elapsed time for the task
progress_timer 精度问题,只能保留到小数点后两位,精确到百分之一秒。
#include <boost/progress.hpp>
using namespace boost;
在构造函数中传入总数,然后迭代更新进度条。
vector<string> v(100);
ofstream fs("test.txt");
progress_display pd(v.size()); // 构造函数,传入进度总数
vector<string>::iterator pos;
for (pos = v.begin(); pos != v.end(); ++pos){ // 遍历迭代,处理字符串,写文件
fs << *pos << endl;
++pd; // 更新进度
}
progress_display 向标准输出 cout 输出字符,无法将进度条和输出分离,如果循环中带有输出,则显示会很难看。