经过接近三个月的离职期之后，我最近得以 光荣上岗。
回顾这三个月，似乎经历了松山湖之行，回乡历程，孤单的七夕节，八月北京奥运，经济的
冰冻期;几经周折，我也完成了助学贷款，习惯了泡图书馆的日子，参与17爬爬吧的活动(1，
2，3) 烦躁的求职生活。
这段时间也正是痛苦和快乐并重，有次扁桃体发炎，疼到吞咽困难也坚持不去看医生；多个
公司下遭遇闭门羹，面试题更是折磨的我苦不堪言；我和莹莹经历了最严重的争吵，甚至有
放弃感情的念头……
不过也终究过来了，我觉得生活还就这样，我也还就这样，2008年也就这样过来了。我总是
对这样苦中作乐的日子念念不忘，我还会回头想起高考的日子，踏上深圳的每一步。我甚至
可以一直这样慢悠悠的闲廷信步，一直等到花光手上所有积蓄，需要到必胜客去打钟点工来
找足乐子。尽管这样随性的性格伤害了一些好朋友。
上个星期回家，老妈告诉我家里的情况很乱。一般家里和游子总是处于“报喜不报忧”的状态
之中，假设他们不告诉家中的情形，那你得总怀揣着担忧的心思；而家人支支吾吾甚至直接
告知情况糟糕的时候，家里一定乱成一团糟了。因此找份工作仍旧是重中之重，回家过年也
会挂上日程。
现在的工作是在一家工控公司作嵌入式开发，公司名称保密。他们会为一些厂家作外包，来
实现一些工控，自动化设施的嵌入式主板，他们也有了PCB设计师，调板工，唯独让人郁闷
的是：除了经理以外，没有开发人员。很显然这个公司还处于起步阶段，办公室位于33层
（最高层），主板扔的到处都是，每个房间都有包装盒堆成的小山，室内环境比清华信息港
差上几个档次。最重要的是——在这个公司， 加班时间将成为家常便饭，而且没有加班费。
于是我进入了这样一个阶段：
心诚则灵，收起邋遢随性的性格，为将来努力吧！
得知一大票人口在我和莹莹就职后也开始找到工作，恭喜你们，也祝愿全球金融冰冻期早日
结束。
自从微软发布WGA更新以后，中国网民的抗议声音不绝于耳： 微软黑屏引发威胁百倍于熊猫烧香，微软黑屏引发国家安全话题，国家版权局将会对此事件 表态。真实情况将会怎样呢？是中国一家之言，还是全球群起反对？是网友过激，还是捍卫 安全呢？
环顾四周，我们才发现，微软黑屏是一个全球性的政策，然而对其他国家来说远远未像中国 那样表现过激，就连香港也对此冷漠。很多普及正版的国家和地区，人民是可以支付正版价 格的；而对于大多数发展中国家来说，他们也有更多的选择。
而就技术方面来说，微软只是针对盗版用户投放信息，现在没有任何组织和个人可以拿出证 据说微软控制电脑和数据。如果你说强制黑屏可以指明微软控制用户的计算机，我觉得这是 捕风捉影。操作系统本身具有利用硬件资源提供服务的功用，而在正常情况下，微软将会根 据EULA，在用户同意后才可以使用，更改任何用户数据，并通知处理用户信息的目的。但是 因为EULA的争议性，中国大陆还在考虑其是否适用。
如果中国官方现在考虑，那我建议微软黑屏和控制电脑之间需要更多的证据。当然我觉得更 值得考虑的事情是：1)盗版用户和软件制作商之间基于什么样的权力关系。2)国家如何扶植 操作系统和办公软件，用以改变对Windows和Office过度依赖的现状。3)如何发展本国自由 软件技术和提高重要机构的信息安全。
MAJOR(dev_t dev); /* 返回主设备号 */
MINOR(dev_t dev); /* 返回次设备号 */
MKDEV(int major, int minor); /* 由主次设备得到dev_t类型的设备编号 */
/* 获得一个或者多个设备编号 */
int register_chrdev_region(dev_t first, unsigned int, char *name);
/* 运行过程中，使用以下函数会为我们恰当分配所需要的设备号 */
int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,
unsigned int count, char *name);
/* 应该用以下函数释放这些设备编号 */
void unregister_chrdev_region(dev_t first, unsigned int count);
#include <linux/fs.h>
struct inode {
struct hlist_node i_hash;
struct list_head i_list;
struct list_head i_sb_list;
struct list_head i_dentry;
unsigned long i_ino;
atomic_t i_count;
unsigned int i_nlink;
uid_t i_uid;
gid_t i_gid;
dev_t i_rdev;
u64 i_version;
loff_t i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
struct timespec i_atime;
struct timespec i_mtime;
struct timespec i_ctime;
unsigned int i_blkbits;
blkcnt_t i_blocks;
unsigned short i_bytes;
umode_t i_mode;
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
struct mutex i_mutex;
struct rw_semaphore i_alloc_sem;
const struct inode_operations *i_op;
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
struct super_block *i_sb;
struct file_lock *i_flock;
struct address_space *i_mapping;
struct address_space i_data;
#ifdef CONFIG_QUOTA
struct dquot *i_dquot[MAXQUOTAS];
#endif
struct list_head i_devices;
union {
struct pipe_inode_info *i_pipe;
struct block_device *i_bdev;
struct cdev *i_cdev;
};
/* ... */
};
struct file {
/*
* fu_list becomes invalid after file_free is called and queued via
* fu_rcuhead for RCU freeing
*/
union {
struct list_head fu_list;
struct rcu_head fu_rcuhead;
} f_u;
struct path f_path;
#define f_dentry f_path.dentry
#define f_vfsmnt f_path.mnt
const struct file_operations *f_op;
atomic_t f_count;
unsigned int f_flags;
mode_t f_mode;
loff_t f_pos;
struct fown_struct f_owner;
unsigned int f_uid, f_gid;
struct file_ra_state f_ra;
u64 f_version;
#ifdef CONFIG_SECURITY
void *f_security;
#endif
/* needed for tty driver, and maybe others */
void *private_data;
/* ... */
};
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*dir_notify)(struct file *filp, unsigned long arg);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};
/* 自定义结构 */
struct scull_qset {
void **data;
struct scull_qset *next;
};
struct scull_dev {
struct scull_qset *data;
int quantum;
int qset;
unsigned long size;
unsigned int access_key;
struct semaphore sem;
struct cdev cdev;
};
struct path f_path;
#define f_dentry f_path.dentry // 目录项结构
const struct file_operations *f_op;
unsigned int f_flags; // 标志，是否阻塞
mode_t f_mode; // 权限检查
loff_t f_pos; // 当前读写位置
/* needed for tty driver, and maybe others */
void *private_data; // 跨系统调用时候保存状态信息
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
.ioctl = scull_ioctl,
.open = scull_open,
.release = scull_release,
};
int scull_init_module(void)
{
int result, i;
dev_t dev = 0;
if (scull_major) {
dev = MKDEV(scull_major, scull_minor);
result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,
"scull");
scull_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
return result;
}
/* allocate the devices -- we can't have them static, as the number
* can be specified at load time.
*/
scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
if (!scull_devices) {
result = -ENOMEM;
goto fail;
}
memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));
/* initialize each device */
for (i = 0; i < scull_nr_devs; i++) {
scull_devices[i].quantum = scull_quantum;
scull_devices[i].qset = scull_qset;
init_MUTEX(&scull_devices[i].sem);
scull_setup_cdev(&scull_devices[i], i);
}
/* At this point call the init function for any friend device */
dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
// dev += scull_p_init(dev);
// dev += scull_access_init(dev);
#ifdef SCULL_DEBUG /* only when debugging */
// scull_create_proc();
#endif
printk(KERN_INFO "init scull successful\n");
return 0; /* succeed */
fail:
scull_cleanup_module();
return result;
}
void scull_cleanup_module(void)
{
int i;
dev_t devno = MKDEV(scull_major, scull_minor);
/* Get rid of our char dev entries */
if (scull_devices) {
for (i = 0; i < scull_nr_devs; i++) {
scull_trim(scull_devices + i);
cdev_del(&scull_devices[i].cdev);
}
kfree(scull_devices);
}
#ifdef SCULL_DEBUG /* use proc only if debugging */
scull_remove_proc();
#endif
/* cleanup_module is never called if registering failed */
unregister_chrdev_region(devno, scull_nr_devs);
/* and call the cleanup functions for friend devices */
// scull_p_cleanup();
// scull_access_cleanup();
printk(KERN_INFO "cleanup scull successful\n");
}
ssize_t scull_read(struct file *filp, char __user *buf,
size_t count, loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = 0;
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
if(*f_pos >= dev->size)
goto out;
if(*f_pos + count > dev->size)
count = dev->size - *f_pos;
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;
dptr = scull_follow(dev, item);
if (dptr == NULL || !dptr->data || !dptr->data[s_pos])
goto out;
if (count > quantum - q_pos)
count = quantum - q_pos;
if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
out:
up(&dev->sem);
return(retval);
}
ssize_t scull_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = 0;
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
if(*f_pos >= dev->size)
goto out;
if(*f_pos + count > dev->size)
count = dev->size - *f_pos;
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;
dptr = scull_follow(dev, item);
if (dptr == NULL)
goto out;
if (!dptr->data) {
dptr->data = kmalloc(qset *sizeof(char *), GFP_KERNEL);
if (!dptr->data)
goto out;
memset(dptr->data, 0, qset * sizeof(char *));
}
if (!dptr->data[s_pos]) {
dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
if (!dptr->data[s_pos])
goto out;
}
if (count > quantum - q_pos)
count = quantum - q_pos;
if (copy_from_user(dptr->data[s_pos] + q_pos, buf, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
/* 更新文件大小 */
if (dev->size < *f_pos)
dev->size = *f_pos;
out:
up(&dev->sem);
return(retval);
}
// c13: malloc_class.cpp
// malloc with class objects
#include <cstdlib>
#include <cstring>
#include <cstring>
#include <iostream>
using namespace std;
class obj {
int i, j, k;
enum { sz = 100 };
char buf[sz];
public:
void initialization() { // can't use constructors
cout << "initialization obj" << endl;
i = j = k = 0;
memset(buf, 0, sz);
}
void destroy() {
cout << "destroy obj" << endl;
}
};
int main()
{
obj *o = (obj*)malloc(sizeof(obj));
if (o == 0)
return -1;
o->initialization();
//sometimes later...
o->destroy();
free(o);
}
/* result:
initialization obj
destroy obj
*/
// c13: new_and_delete.cpp
#include <iostream>
using namespace std;
class tree {
int height;
public:
tree(int tree_height): height(tree_height) {}
~tree() { cout << "*"; }
friend ostream& operator <<(ostream &os, const tree* t) {
return os << "tree height is: "
<< t->height << std::endl;
}
};
int main(void)
{
tree *t = new tree(40);
cout << t;
delete t;
}
/* result
tree height is: 40
*/
// c13: bad_void_pointer_deletion.cpp
#include <iostream>
using namespace std;
class object {
void *data;
const int size;
const char id;
public:
object(int sz, char c): size(sz), id(c) {
data = new char[size];
cout << "constructing object" << id
<< ", size = " << size << endl;
}
~object() {
cout << "desctructing object " << id << endl;
delete []data; // OK, just release storage;
// no desctructor calls are necessary;
}
};
int main() {
object *a = new object(40, 'a');
delete a;
void *b = new object(40, 'b');
delete b;
}
/* result:
constructing objecta, size = 40
desctructing object a
constructing objectb, size = 40
*/
// c13: new_handler.cpp
#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;
int count = 0;
void out_of_memory()
{
cerr << "memory exhausted after " << count << " allocations" << endl;
exit(1);
}
int main()
{
set_new_handler(out_of_memory);
while(1) {
count++;
new int[1000];
}
}
// reference.cpp
int *f(int *x)
{
(*x)++;
return x;
}
int &g(int &x)
{
x++;
return x;
}
int &h()
{
int q;
//! return q; // error
static int x;
return x;
}
int main()
{
int a = 0;
f(&a);
g(a);
}
// const_ref.cpp
void f(int&) {}
void g(const int&) {}
int main() {
//! f(1); //invalid initialization of non-const reference
g(1);
}
// c11: ref_to_pointer.cpp
#include <iostream>
using namespace std;
void increment(int* &i) { i++; }
int main()
{
int *i = 0;
cout << "i = " << i << endl;
increment(i);
cout << "i = " << i << endl;
}
// c11: howmany.cpp
#include <fstream>
#include <string>
using namespace std;
ofstream out("howmany.out");
class howmany {
static int object_cnt;
public:
howmany() { object_cnt++; }
static void print(const string& msg = "") {
if (msg.size() != 0)
out << msg << ": ";
out << "object_cnt = " << object_cnt << endl;
}
~howmany() {
object_cnt--;
print("~howmany()");
}
};
int howmany::object_cnt = 0;
// pass and return by value:
howmany f(howmany x)
{
x.print("x argument inside f()");
return x;
}
int main()
{
howmany h;
howmany::print("after construction of h");
howmany h2 = f(h);
howmany::print("after call to f()");
}
/* result:
after construction of h: object_cnt = 1
x argument inside f(): object_cnt = 1
~howmany(): object_cnt = 0
after call to f(): object_cnt = 0
~howmany(): object_cnt = -1
~howmany(): object_cnt = -2
*/
// c11: howmany.cpp
#include <fstream>
#include <string>
using namespace std;
ofstream out("howmany2.out");
class howmany2 {
string name;
static int object_cnt;
public:
howmany2(const string &id = ""): name(id) {
++object_cnt;
print("howmany2()");
}
~howmany2() {
--object_cnt;
print("~howmany()");
}
howmany2(const howmany2 &h): name(h.name) {
name += " copy";
++object_cnt;
print("howmany2(const howmany2&)");
}
void print(const string& msg = "") const {
if (msg.size() != 0)
out << msg << endl;
out << '\t' << name << ": "
<< "object_cnt = " << object_cnt << endl;
}
};
int howmany2::object_cnt = 0;
// pass and return by value:
howmany2 f(howmany2 x)
{
x.print("x argument inside f()");
return x;
}
int main()
{
howmany2 h("h");
out << "entering f()" << endl;
howmany2 h2 = f(h);
h2.print("h2 after call to f()");
out << "call f(), no return value" << endl;
f(h);
out << "after call to f()" << endl;
}
/*
howmany2()
h: object_cnt = 1
entering f()
howmany2(const howmany2&)
h copy: object_cnt = 2
x argument inside f()
h copy: object_cnt = 2
howmany2(const howmany2&)
h copy copy: object_cnt = 3
~howmany()
h copy: object_cnt = 2
h2 after call to f()
h copy copy: object_cnt = 2
call f(), no return value
howmany2(const howmany2&)
h copy: object_cnt = 3
x argument inside f()
h copy: object_cnt = 3
howmany2(const howmany2&)
h copy copy: object_cnt = 4
~howmany()
h copy copy: object_cnt = 3
~howmany()
h copy: object_cnt = 2
after call to f()
~howmany()
h copy copy: object_cnt = 1
~howmany()
h: object_cnt = 0
*/
// c11: default_cc.cpp
// automatic creation of the copy-constructor
#include <iostream>
#include <string>
using namespace std;
class withcc {
public:
withcc() {}
withcc(const withcc &) {
cout << "withcc(withcc &)" << endl;
}
};
class wocc {
string id;
public:
wocc(const string &ident = ""): id(ident) {}
void print(const string &msg = "") const {
if (msg.size() != 0)
cout << msg << ": ";
cout << id << endl;
}
};
class composite {
withcc tc;
wocc oc;
public:
composite(): oc("composite()") {}
void print(const string &msg = "") const {
oc.print(msg);
}
};
int main() {
composite c;
c.print("content of c");
cout << "calling composite copy-constructor" << endl;
composite c2 = c;
c2.print("content of c2");
}
/* reuslt
content of c: composite()
calling composite copy-constructor
withcc(withcc &)
content of c2: composite()
*/
// c10: no_cc.cpp
class nocc {
int i;
nocc(const nocc &);
public:
nocc(int ii = 0): i(ii) {}
};
void f(nocc);
int main(void)
{
nocc n;
// copy-constructor is private!
//! f(n);
//! nocc n2 = n;
//! nocc n3(n);
}
// c10: static_objects_inside_funcs.cpp
#include <iostream>
using namespace std;
class X {
int i;
public:
X(int ii = 0):i(ii) {}
~X() { cout << "X::~X()" << endl; }
};
void f()
{
static X x1(47);
static X x2;
}
int main()
{
f();
} ///:~
/* result:
X::~X()
X::~X()
*/
// c10: static_destructors.cpp
// static object destructors
#include <fstream>
using namespace std;
ofstream out("statdest.out");
class obj {
char c;
public:
obj(char cc): c(cc) {
out << "obj::obj() for " << c << endl;
}
~obj() {
out << "obj::~obj() for " << c << endl;
}
};
obj a('a');
void f()
{
static obj b('b');
}
void g()
{
static obj c('c');
}
int main()
{
out << "inside main()" << endl;
f();
//g() not called
out << "leaving main()" << endl;
}
/* statdest.out:
obj::obj() for a
inside main()
obj::obj() for b
leaving main()
obj::~obj() for b
obj::~obj() for a
*/
// c10: local_extern.cpp
#include <iostream>
int main()
{
extern int i;
std::cout << i << endl;;
}
/* result:
5
*/
// c10: local_extern2.cpp
int i = 5;
// c10: continuation.cpp
namespace mylib {
extern int x;
void f();
}
namespace mylib {
extern int y;
void g();
}
int main() {}
// c10: namespace_int.h
#ifndef __NAMESPACEINT_H
#define __NAMESPACEINT_H
namespace Int {
enum sign { positive, negative };
class Integer {
int i;
sign s;
public:
Integer(int ii = 0): i(ii),
s(i >= 0 ? positive : negative)
{}
sign get_sign() const { return s; }
void set_sign(sign sgn) { s = sgn; }
}
}
#endif /// __NAMESPACEINT_H
// c10: namespace_math.h
#ifndef __NAMESPACEMATH_H
#define __NAMESPACEMATH_H
#include "namespace_int.h"
namespace Math {
using namespace int;
Integer a, b;
Integer divide(Integer, Integer);
}
#endif /// __NAMESPACEMATH_H
// c10: arithmetic.cpp
#include "namespace_math.h"
void arithmetic()
{
using namespace Int;
Integer x;
x.set_sign(positive);
}
int main() {}
// c10: static_init.cpp
#include <iostream>
using namespace std;
int x = 100;
class with_static {
static int x;
static int y;
public:
void print() const {
cout << "with_static::x = " << x << endl;
cout << "with_static::y = " << y << endl;
}
};
int with_static::x = 1;
int with_static::y = x + 1;
// with_static::x not ::x
int main()
{
with_static ws;
ws.print();
}
/*
with_static::x = 1
with_static::y = 2
*/
// c10: static_array.cpp
class values {
static const int scsize;// = 100;
static const long sclong = 100;
static const int scints[];
static const long sclongs[];
static const float sctable[];
static const char scletters[];
static int size;
static const float scfloat; // differ from tic++
static float table[];
static char letters[];
};
int values::scsize = 100;
int values::size = 100;
const float values::scfloat = 1.1;
const int values::scints[] = { 99, 47, 33, 11, 7 };
const long values::sclongs[] = { 99, 47, 33, 11, 7 };
const float values::sctable[] = { 1.1, 2.2, 3.3, 4.4 };
const char values::scletters[] = { 'a','b','c','d','e','f','g','h','i','j',};
float values::table[4] = { 1.1, 2.2, 3.3, 4.4 };
char values::letters[10] = { 'a','b','c','d','e','f','g','h','i','j',};
int main() { values v; }
// c10: local.cpp
// static member & local classes
#include <iostream>
using namespace std;
// Nested classes CAN have static data members;
class outer {
class inner {
static int i;
};
};
int outer::inner::i = 47;
//local class can not have static data members;
void f()
{
class local {
public:
//! static int i; // error
// (how could you define i?)
} x;
}
int main()
{
outer x;
f();
}
// c10: static_member_funcs.cpp
class X {
int i;
static int j;
public:
X(int ii = 0): i(ii) {
// non-static member function can
// access static member function or data
j = i;
}
int val() const { return i; }
static int incr() {
//! i++; // Error: static member function
// cannot access non-static member data
return ++j;
}
static int f() {
//! val(); // Error: static member function
// cannot access non-static member function
return incr();
}
};
int X::j = 0;
int main()
{
X x;
X *xp = &x;
x.f();
xp->f();
X::f(); // only works with static members
} ///:~
// c10: singleton.cpp
#include <iostream>
using namespace std;
class egg {
static egg e;
int i;
egg(int ii): i(ii) {}
egg(const egg&); // prevent copy-construction
public:
static egg* instance() { return &e; }
int val() const { return i; }
};
egg egg::e(47);
int main()
{
//! egg x(1); // private constructor
cout << egg::instance()->val() << endl;
}
// c10: initializer.h
#ifndef __INITIALIZER_H
#define __INITIALIZER_H
#include <iostream>
extern int x;
extern int y;
class initializer {
static int init_count;
public:
initializer() {
std::cout << "initializer()" << std::endl;
//initialize first time only
if (init_count++ == 0) {
std::cout << "performing initialization"
<< std::endl;
x = 100;
y = 200;
}
}
~initializer() {
std::cout << "initializer()" << std::endl;
//cleanup last time only
if (--init_count == 0) {
std::cout << "performing cleanup"
<< std::endl;
// any necessary cleanup here
}
}
};
static initializer init;
#endif//__INITIALIZER_H
// c10: initializer_defs.cpp
#include "initializer.h"
int x;
int y;
int initializer::init_count;
// c10: initializer.cpp
#include "initializer.h"
using namespace std;
int main()
{
cout << "inside main()" << endl;
cout << "leaving main()" << endl;
}
/* result:
initializer()
performing initialization
initializer()
inside main()
leaving main()
initializer()
initializer()
performing cleanup
*/
extern std::ofstream out;
class Oof {
public:
Oof() { std::out << "ouch"; }
} Oof;
// c10: dependency1.h
#ifndef __DEPENDENCY1_H
#define __DEPENDENCY1_H
#include <iostream>
class dependency1 {
bool init;
public:
dependency1(): init(true) {
std::cout << "dependency1 construction"
<< std::endl;
}
void print() const {
std::cout << "dependency1 init:"
<< init << std::endl;
}
};
#endif//__DEPENDENCY1_H
// c10: dependency2.h
#ifndef __DEPENDENCY2_H
#define __DEPENDENCY2_H
#include "dependency1.h"
class dependency2 {
dependency1 d1;
public:
dependency2(const dependency1 &dep1): d1(dep1) {
std::cout << "dependency2 construction ";
print();
}
void print() const { d1.print(); }
};
#endif//__DEPENDENCY2_H
// c10: dependency1statfun.h
#ifndef __DEPENDENCY1STATFUN_H
#define __DEPENDENCY1STATFUN_H
#include "dependency1.h"
extern dependency1 &d1();
#endif//__DEPENDENCY1STATFUN_H
// c10: dependency2statfun.h
#ifndef __DEPENDENCY2STATFUN_H
#define __DEPENDENCY2STATFUN_H
#include "dependency2.h"
extern dependency2 &d2();
#endif//__DEPENDENCY2STATFUN_H
// c10: dependency1statfun.cpp
#include "dependency1statfun.h"
dependency1 &d1()
{
static dependency1 dep1;
return(dep1);
}///:~
// c10: dependency2statfun.cpp
#include "dependency1statfun.h"
#include "dependency2statfun.h"
dependency2 &d2()
{
static dependency2 dep2(d1());
return(dep2);
}
// c10: technique2b.cpp
// (L) dependency1statfun dependency2statfun
#include "dependency2statfun.h"
int main()
{
d2();
}///:~
/* result:
dependency1 construction
dependency2 construction dependency1 init:1
*/
// c09: macro_side_effects.cpp
#include <fstream>
using namespace std;
#define BAND(x) (((x) > 5 && (x) < 10) ? (x) : 0)
int main()
{
ofstream out("macro.out");
// assure(out, "macro.out");
for (int i = 4; i < 11; i++) {
int a = i;
out << "a = " << a << endl << "\t";
out << "BAND(++a)" << BAND(++a) << endl;
out << "\t a = " << a << endl;
}
}
/* macro.out:
a = 4
BAND(++a)0
a = 5
a = 5
BAND(++a)8
a = 8
a = 6
BAND(++a)9
a = 9
a = 7
BAND(++a)10
a = 10
a = 8
BAND(++a)0
a = 10
a = 9
BAND(++a)0
a = 11
a = 10
BAND(++a)0
a = 12
*/
// c09: inline.cpp
#include <iostream>
#include <string>
using namespace std;
class Point {
int i, j, k;
public:
Point(): i(0), j(0), k(0) {}
Point(int ii, int jj, int kk)
: i(ii), j(jj), k(kk) {}
void print(const string &msg = "") const
{
if (msg.size() != 0)
cout << msg << endl;
cout << "i = " << i << ","
<< "j = " << j << ","
<< "k = " << k << endl;
}
};
int main()
{
Point p, q(1,2,3);
p.print("value of p");
q.print("value of q");
}
// c09: stash4.h
// inline functions
#ifndef __STASH4_H
#define __STASH4_H
class stash {
int size;
int quantity;
int next;
unsigned char *storage;
void inflate(int increase);
public:
stash(int sz): size(sz), quantity(0), next(0), storage(0) {}
stash(int sz, int init_quantity): size(sz), quantity(0), next(0), storage(0)
{
inflate(init_quantity);
}
~stash()
{
if (storage != 0)
delete []storage;
}
void *fetch(int index) const
{
if (index >= next)
return 0;
return &(storage[index * size]);
}
// declarations of non-inline functions
int add(void *element);
int count() const { return next; }
};
#endif // __STASH4_H
// c09: stash4.cpp
#include "stash4.h"
#include <iostream>
#include <cassert>
using namespace std;
const int increment = 100;
int stash::add(void *element)
{
if (next >= quantity)
inflate(increment);
int start_bytes = next * size;
unsigned char *e = (unsigned char*)element;
for (int i = 0; i < size; i++)
storage[start_bytes + i] = e[i];
next ++;
return(next -1);
}
void stash::inflate(int increase)
{
assert(increase >= 0);
if (increase == 0)
return;
int new_quantity = quantity + increase;
int new_bytes = new_quantity * size;
int old_bytes = quantity * size;
unsigned char *b = new unsigned char[new_bytes];
for (int i = 0; i < old_bytes; i++)
b[i] = storage[i];
delete [](storage);
storage = b;
quantity = new_quantity;
}
///:~
// c09: stash4test.cpp
#include "stash4.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
int main()
{
stash int_stash(sizeof(int));
for (int i = 0; i < 100; i++)
int_stash.add(&i);
for (int j = 0; j < int_stash.count(); j++)
cout << "int_stash.fetch(" << j << ") = "
<< *(int*)int_stash.fetch(j)
<< endl;
const int bufsize = 80;
stash string_stash(sizeof(char) * bufsize, 100);
ifstream in("stash4test.cpp");
string line;
while(getline(in, line))
string_stash.add((char*)line.c_str());
int k = 0;
char *cp;
while ((cp = (char*)string_stash.fetch(k++)) != 0)
cout << "string_stash.fetch(" << k << ") = "
<< cp << endl;
}
/* result: 结果中途省略
int_stash.fetch(0) = 0
int_stash.fetch(1) = 1
int_stash.fetch(2) = 2
int_stash.fetch(3) = 3
...
int_stash.fetch(98) = 98
int_stash.fetch(99) = 99
string_stash.fetch(1) = // c09: stash4test.cpp
string_stash.fetch(2) = #include "stash4.h"
string_stash.fetch(3) = #include <fstream>
string_stash.fetch(4) = #include <iostream>
string_stash.fetch(5) = #include <string>
string_stash.fetch(6) = using namespace std;
string_stash.fetch(7) =
string_stash.fetch(8) = int main()
string_stash.fetch(9) = {
...
string_stash.fetch(31) = }
*/
// c09: evaluation_order.cpp
// inline evaluation order
class forward {
int i;
public:
forward(): i(0) {}
// call undeclared function
int f() const { return g() + 1; }
int g() const { return 1; }
};
int main()
{
forward fwd;
fwd.f();
}
//safecons.cpp
#include <iostream>
using namespace std;
const int i = 100;
const int j = i + 10;
long address = (long)&j;
char buf[j + 10];
int main(void)
{
cout << "type a character & CR: ";
const char c = cin.get();
const char c2 = c + 'a';
cout << c2 << endl;
}
// c08: const_pointer.cpp
const int *u; // pointer to const int, init not required
int const *v; // still pointer to const int!
int d = 1;
int * const w = &d; // const pointer
const int * const x = &d; // const pointer to const object
int const * const x2 = &d;
int main(void){}
// c08: pointer_assignment.cpp
int d = 1;
const int e = 2;
int *u = &d;
//! int *v = &e; // illegal -- a const
int *w = (int*)&e; // legal but bad practice
int main(){}
// c08: constval.cpp
// return consts by value
// has no meaning for built-in type
int f3() { return 1;}
const int f4() { return 1;}
int main(void)
{
const int j = f3(); // Works fine
int k = f4(); // But this works fine too!
}
// c08: const_return_values.cpp
// const return by value
// result cannot be used as an lvalue
class X {
int i;
public:
X(int ii = 0);
void modify();
};
X::X(int ii)
{
i = ii;
}
void X::modify()
{
i++;
}
X f5()
{
return X();
}
const X f6()
{
return X();
}
void f7(const X& x) // pass non-const reference
{
x.modify();
}
int main()
{
f5() = X(1);
f5().modify();
// compile-time error
//! f6() = X(1);
//! f6().modify();
//! f7(f5());
//! f7(f6()); // 29
}
// c08: const_pointer2.cpp
void t(int*) {}
void u(const int *cip)
{
//! *cip = 2; // illegal -- modifies value
int i = *cip; // OK -- copies value
//! int *ip2 = cip; // illegal: non-const
}
const char *v()
{
// return address of a static array
return "result of function v()";
}
const int * const w()
{
static int i;
return &i;
}
int main()
{
int x = 0;
int *ip = &x;
const int *cip = &x;
// passing addresses
t(ip); // non-const* to non-const*
//! t(cip); // const* to non-const*
u(ip); // non-const* to const*
u(cip); // const* to const*
// returning addresses
//! char *cp = v(); // const* to non-const*, not OK
const char * ccp = v(); // const* to const*
//! int *ip2 = w(); // const* to non-const*, not OK!
const int * const ccip = w(); // const* to const*
const int * cip2 = w();
//! *w() = 1; // modify consts, not OK
}
// c08: const_init.cpp
#include <iostream>
using namespace std;
class Fred {
const int size;
public:
Fred(int sz);
void print();
};
Fred::Fred(int sz) : size(sz) {}
void Fred::print() { cout << size << endl; }
int main()
{
Fred a(1), b(2), c(3);
a.print(), b.print(), c.print();
}
// c08: string_stack.cpp
// using static const to create a compile-time constant
// inside a class
#include <cstring>
#include <string>
#include <iostream>
using namespace std;
class string_stack {
static const int size = 100; // a static constant
const string *stack[size];
int index;
public:
string_stack();
void push(const string *s);
const string *pop();
};
string_stack::string_stack():index(0)
{
memset(stack, 0, size * sizeof(string*));
}
void string_stack::push(const string *s)
{
if (index < size)
stack[index++] = s;
}
const string *string_stack::pop()
{
if (index > 0) {
const string *rv = stack[--index];
stack[index] = 0;
return rv;
}
return 0;
}
const string icecream[] = {
"pralines & cream",
"fudge ripple",
"jamocha almond fudge",
"wild mountain blackberry",
"raspberry sortbet",
"lemon swirl",
"rocky road",
"deep chocolate fudge"
};
const int icsz = sizeof(icecream) / sizeof(*icecream);
int main()
{
string_stack ss;
for(int i = 0; i < icsz; i++)
ss.push(&icecream[i]);
const string *cp;
while((cp = ss.pop()) != 0)
cout << *cp << endl;
}
// c08: const_member.cpp
class X {
int i;
public:
X(int ii);
int f() const; // const member func
int g();
};
X::X(int ii): i(ii) {}
int X::f() const { return i;}
int X::g() {}
int main()
{
X x1(10);
const X x2(20);
x1.f();
x2.f();
//! x2.g(); // discards qualifiers
}
// c08: quoter.cpp
// random quote selection
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
class quoter {
int lastquote;
public:
quoter();
int get_lastquote() const; // const member func
const char *quote(); // member func which returns a const pointer
};
quoter::quoter()
{
lastquote = -1;
srand(time(0));
}
int quoter::get_lastquote() const
{
return lastquote;
}
const char *quoter::quote()
{
static const char *quotes[] = {
"Are we having fun yet?",
"Doctors always know best",
"Is it ... Atomic?",
"Fear is obscene",
"There is scientific evidence "
"to support the idea "
"that life is serious",
"Things that make us happy, make us wise",
};
const int qsize = sizeof quotes / sizeof *quotes;
int qnum = rand() % qsize;
while (lastquote >=0 && qnum == lastquote)
qnum = rand() % qsize;
return quotes[lastquote = qnum];
}
int main()
{
quoter q;
const quoter cq;
cq.get_lastquote();
//! cq.quote(); // 常量型对象无法调用非常量型成员方法
for (int i = 0; i < 20; i++)
cout << q.quote() << endl;
}
// c08: castaway.cpp
class Y {
int i;
public:
Y();
void f() const;
};
Y::Y(): i(0) {}
void Y::f() const
{
//! i++;
((Y*)this)->i++;
// Better: use C++ explicit cast syntax:
(const_cast<Y*>(this))->i++;
}
int main()
{
const Y yy;
yy.f();
}
// c08: mutable.cpp
class Z {
private:
int i;
mutable int j;
public:
Z();
void f() const;
};
Z::Z(): i(0), j(0) {}
void Z::f() const
{
//! i++; // error - const mem func
j++;
}
int main()
{
const Z zz;
zz.f();
}
// c08: volatile.cpp
class comm {
const volatile unsigned char byte;
volatile unsigned char flag;
enum { bufsize = 100 };
unsigned char buf[bufsize];
int index;
public:
comm();
void isr() volatile;
char read(int index) const;
};
comm::comm(): index(0), byte(0), flag(0) {}
// only a demo; won't actually work as an interrupt service routine:
void comm::isr() volatile
{
flag = 0;
buf[index++] = byte;
if (index >= bufsize)
index = 0;
}
char comm::read(int index) const
{
if (index < 0 || index >= bufsize)
return 0;
return buf[index];
}
int main()
{
volatile comm port;
port.isr(); // OK
//! port.read(0); // Error, read() not volatile
}
//unionclass.cpp
#include
using namespace std;
union u {
private:
int i;
float f;
public:
u(int a);
u(float b);
~u();
int read_int();
float read_float();
};
u::u(int a)
{
i = a;
}
u::u(float b)
{
f = b;
}
u::~u(void)
{
cout << "u::~u()\n"; } int u::read_int(void) { return i; } float u::read_float(void) { return f; } int main(void) { u X(12), Y(1.9F); cout <<>
//supervar.cpp
#include
using namespace std;
class supervar {
enum {
character,
integer,
floating_point,
} vartype;
union { // anonymous union
char c;
int i;
float f;
};
public:
supervar(char ch);
supervar(int ii);
supervar(float ff);
void print();
};
supervar::supervar(char ch)
{
vartype = character;
c = ch;
}
supervar::supervar(int ii)
{
vartype = integer;
i = ii;
}
supervar::supervar(float ff)
{
vartype = floating_point;
f = ff;
}
void supervar::print(void)
{
switch (vartype) {
case character:
cout << "character: " <<>
