(e) 起泡排序
为了使得向量有序, 要对向量进行排序。

# 排序器, ADT 统一入口:
	>* 实现
		====================== source code ===========================
		template <typename T>
		void Vector<T>::sort(Rank lo, Rank hi) {
			int i = 1;
			switch (i) {
				case 1: bubbleSort(lo, hi); break;     // 起泡排序
				case 2: selectionSort(lo, hi); break;  // 选择排序(习题)
				case 3: mergeSort(lo, hi); break;      // 归并排序
				case 4: heapSort(lo, hi); break;       // 堆排序(ch 10)
				default: quickSort(lo, hi); break;     // 快速排序(12)
			}
		}
		=============================================================
----------------------------------------------------------------------------------

# 起泡排序
	>* 改进思路
		未必要对未确定序列的全序进行扫描, 其中有一部分可能是有序的, 也可能剩余序列完全有序。
		在上一趟扫描中, 记录有序对

(d4) 有序向量: 二分查找(改进)
-----------------------------

# 版本B, 改进思路:
	>* 左右转向成本平衡：
		无论向左还是向右进行一次比较。
	
	>* 轴点mi为中点, 每查找深入一层, 问题规模缩减一半
		1, e <  x: e若存在则在左侧子区间S[lo, mi), 可递归深入
		2, x <= e: e若存在则在右侧子区间S[mi, hi), 可递归深入
		只有当hi - lo = 1时, 判断元素是否命中。
		
# 实现:
	>* 我的尝试
		=========================  source code =======================
		template <typename T>
		Rank Vector<T>::binBlcSearch(T* elem, T const& e, Rank lo, Rank hi) const {
			// 二分平衡查找算法
			while (1 < hi - lo) {
				int mi = (lo + hi) >> 1;          // 轴点为中点
				if (e < elem[mi]) hi = mi;        // 深入左区间
				else if (elem[mi] <= e) lo = mi;  // 深入右区间
			}
			// hi - lo == 1, 判断当前元素是否命中
			if (e == elem[lo]) return lo;
			else               return -1;
		}
		===========================================================
		思路上无问题, 但代码可以简化。
		
	>* 更为简洁的写法
		=====
	    template <typename T>
		Rank Vector<T>::binBlcSearch(T* elem, const T& e, Rank lo, Rank hi) const {
			while (1 < hi - lo) {
			int mi = (lo + hi) >> 1;               // 轴点为中点
			(e < elem[mi]) ? hi = mi : lo = mi;    // 在哪个区间上深入
			}    // 退出循环时, 区间长度1, elem[lo]为有效元素
			return (e == elem[lo])? lo: -1;
		}        // 相对于binSearch A版本, 最好(坏)情况下更坏(好)
		====
		
		1, 两种情况if...else 用以下代替
			(cond)? expr1 : expr2;
		2, 在其中使用返回语句
			(cond) ? return expr1 : return expr2;    // ERROR!!
			return (cond) ? expr1 : expr2;           // Right!!
----------------------------------------------------------------------------------

# 语义约定
	>* 为什么要语义约定?
		便于其他高阶操作的调用。
		v.insert(1 + search(e, lo, hi), e);
			：在找到元素索引的下个索引处插入。
	
	>* 思路
		1, 有多个元素匹配时, 返回最大秩(不大于e的最后一个元素秩)
		2, 未匹配元素时, 返回小于e的最大者秩(含哨兵[lo - 1])
	
	>* 实现, 版本C
		>* 我的尝试
		将原来的 return (e == elem[lo]) ? lo : -1; 改为:
		============= source code ============================
		if (e == elem[lo]) {  // 存在匹配
			while (elem[lo+1] == elem[lo]) lo++;  // 返回最大秩
			return lo;
		} else {  // 无匹配
			return (e < elem[lo]) ? lo - 1 : lo;  // 返回小于e的最大者秩
		}
		=======================================================
		一次while循环找到最大匹配的索引, 一次判断确定不匹配时返回秩
		
		>* 更优解
		==================== source code ===========================
		template <typename T>
		Rank Vector<T>::binBlcSearch(T* elem, const T& e, Rank lo, Rank hi) const {
			while (lo < hi) {  // 区间缩短至0
				int mi = (lo + hi) >> 1;                   // 轴点为中点
				(e < elem[mi]) ? hi = mi : lo = mi + 1;    // [lo, mi), (mi, hi)
			}    // 退出循环时, 区间长度0, A[lo = hi]为大于e的最小元素
			return --lo;    // 故lo-1 为不大于e的最大秩
		}      // 相对于binSearch A版本, 最好(坏)情况下更坏(好)
		=============================================================
	
	>* 更优解实现分析
		>* 差别
			1, 循环结束区间宽度0, 而非1
			2, 转入右侧子向量时, 左边界取作mi + 1而非mi, elem[mi]看似遗漏?
			3, 无论成功与否, 返回秩序严格符合定义的语义接口。
			4, 和我的实现比起来, 无需多余的while和if判断
----------------------------------------------------------------------------------

# 版本C, 正确性:
	>* 不变性:
		A[0, lo) <= e < A[hi, n)          // A[hi] 总是大于e的最小者
	>* 初始
		lo = 0且hi = n, A[0, lo) = A[hi, n) = 空集, 自然成立
	>* 数学归纳两种情况,
		这两种情况不是很清楚。以后可以回过头来看看。

(d3) 有序向量: Fibonacci查找

1, 思路
	向左侧1次, 向右两次。
	表面平衡, 内部极大不平衡。
	比较次数不等, 递归深度却相等。
	
	左侧更深, 右侧更浅。
	递归深度不平衡, 对转向成本不同进行补偿。
	
	若 n = fib(k) - 1, 则mi = fib(k-1) - 1
	前向量fib(k-1) - 1, 后向量fib(k-2) - 1
--------------------------------------------------------------------------------
2, 实现
	>* 我的尝试, 定义fib类
		====== source code ====
		// ERROR:my test fib
		// 定义fibonacci相关的类
		class Fib {
			int* _fib_lst; int _size;
			public:
			// 构造函数
			explicit Fib(const int n) : _size(n) {
				emptyFib(n);
				fib(n-1, _fib_lst);
			}
			
			// 将数列置空
			void emptyFib(const int n) {
				// 初始化0
				for (int i = 0; i < n; i++) {
				_fib_lst[i] = 0;
				}
			}
			
			// 生成fib数列
			int fib(const int n, int* _fib_lst) {
				if (_fib_lst[n] != 0) {
					return _fib_lst[n];
				} else {
					if (n < 2) {_fib_lst[n] = n;} else {
						_fib_lst[n] = fib(n-1, _fib_lst)  + fib(n-2, _fib_lst);
						return _fib_lst[n];
					}
				}
			}
			// 获得数列中某一索引的值
			int& get(const int& n) const {return _fib_lst[n];}
			
			int index(const int v) const {
				// 获得某一值在fib数列对应的索引
				for (int i = 0; i < _size; i++) {
					if (v == _fib_lst[i]) return i;
					if (v < _fib_lst[i]) return -1;    // 比当扫描值大还没找到, 返回失败
				}
				return -1;    // 在扫描过程中没找到, 返回失败
			}
			
			// 打印数列
			void printFib() const {
				std::cout << "---- print fib series -----\n";
				for (int i = 0; i < _size; i++) {
					std::cout << i <<": _fib_lst[i]"
						<< _fib_lst[i] << std::endl;	
				}
				std::cout << "_size = " << _size << std::endl;
			}
		};
		==================================================
		运行总是溢出, 找不到出错位置。
		考虑先right, 后fast

	>* 根据课件的修改
		=================== source code ==========================
		// 定义fib相关的类
		class Fib {
			int _size;
			
			public:
			explicit Fib(int n) : _size(n) {}
			int createFib(int n) {
				return (2 > n) ? n: createFib(n-1) + createFib(n-2);
			}
			
			// 获得当前项
			int get() {
				int result = createFib(_size - 1);
				return result;
			}
			
			// 获得前一项
			int prev() {
				if (0 < _size - 1) {
				int result = createFib(--_size - 1);
				return result;
				}
				return -1;
			}
		};
		===========================================================
		先使用了低效的fib生成函数, 且不储存在一个list中。
		
		以及查找函数
		======================== source code ========================
		template <typename T>
		Rank Vector<T>::fibSearch(T* elem, T const& e, Rank lo, Rank hi) const {
			Fib fib(hi - lo);
			while (lo < hi) {
				while ((hi - lo) < fib.get()) fib.prev();
				int priv = lo + fib.get() - 1;
				if      (e < elem[priv]) hi = priv;
				else if (elem[priv] < e) lo = priv + 1;
				else                     return priv;
			}
		    return -1;
		}
		=============================================================
		本质是选择轴点不同。
	>* 改进fib类
		用动态规划求解fib数列中的某一项
		================= source code ==============================
		int createFib(int n) {
			int f = 0, g = 1;          // fib(0) = 0; fib(1) = 1;
			if (n < 2) {int r = (n) ? g : f; return r;}
			while (0 < n--) {
				g = g + f;
				f = g - f;
			}
			return g;
		}
		===========================================================
-----------------------------------------------------------------------------------
3, 查找最优性
	>* 通用策略: 
		对任何A[0, n), 总是取得A[lambda*n]作为轴点, 0 <= lambda < 1
		二分0.5, fibonacci对应lambda  = 0.6180339
	>* 递推式和微积分求极值
		这个...
		
-------------------------------------------------------------------------------
4, 总结
	这个算法花费很长时间去实现, 原因如下：
		1, 面向对象不理解, 为什么定义fib类
		2, 先选择了fast, not right

1, 局部变量的销毁顺序
	================= source code ===============================
	void f(int i) {
		Table aa(1);
		Table bb(2);
		if (i > 0) {
			Table cc(3);
		}
		Table dd(4);
	}
	-------------- ./a.out ----------------
	in Table() sz = 1
	in Table() sz = 2
	in Table() sz = 3
	in ~Table() sz = 3        // cc在if退出时析构, 在dd构造之前
	in Table() sz = 4
	in ~Table() sz = 4        // a, b, c构造; c, b, a析构
	in ~Table() sz = 2
	in ~Table() sz = 1
	=============================================================
-------------------------------------------------------------------------------------

2, 构造函数复制

	>* 直接复制
		======= source code ========
		void h() {
			Table t1;
			// Table t2 = t1;    // ERROR: 复制初始化
			Table t3;
			
			// t3 = t2;          // ERROR: 复制赋值
		}
		==============================
		
		t1所创建而分配的数组, 将同时分配给t1, t2, t3, 被删除3次。
		所导致结果是无意义的


	>* 清楚定义复制构造函数
		================ source code =======================
		Table::Table(const Table& t) {
			p = new Name[sz = t.sz];
			for (int i = 0; i < sz; i++) {
				p[i] = t.p[i];
			}
		}
		
		Table& Table::operator=(const Table& t) {
			if (this != &t) {         // 防止自复制
				delete[] p;
				p = new Name[sz = t.sz];
				for (int i = 0; i < sz; i++) {p[i] = t.p[i];}
			}
			return *this;
		}
		void f() {
			Table t1(2);
			Table t2 = t1;
			Table t3(t1);
		}
		----------- ./a.out --------------------
		in Table() sz = 2
		in ~Table() sz = 2
		in ~Table() sz = 2
		in ~Table() sz = 2
		===================================================
	
	>* 原因
		在复制构造函数中, 对之前未初始化的储存区域初始化, 而不会造成储存丢失的情况。这在C++中用new和delete我不清楚在C和其他语言中如何做到, delete有何劣势等等。
		
		而复制赋值符要对结构本身有些优化, 如： 防止自赋值, 删除那些老元素, 初始化, 复制那些新元素, 通常每个非静态成员都必须复制, 可以通过异常去报告复制中的出错。
----------------------------------------------------------------------------------------
		
3, 类和数组的关系
	>* 发现问题
		为什么能对指针类型使用索引?
	
	>* 测试
		========= source code =====================
		class Name {
			const char* s;
		};
	
		void test_array() {
			Name* t;
			t[0];          // t是指针也是数组
			
			int i = 5;
			int* ptr_i = &i;
			int r = ptr_i[0];     // ptr_i是指针也是数组
			std::cout << "r = " << r << std::endl;    // prints r = 5
		}
		=========================================
		
	>* 某一类型的指针, 也同样是指向某一类型的数组。
		到现在为止, 可以把指针理解成一个表。 比如 int i, j, k; 三个整型。如何用一个变量将他们表示? 
		========= source code ===========
		int a = 2, b = 3, c = 4;
		int table_v[] = {a, b, c};
		std::cout << *table_v << std::endl;
		-------./a.out---------------------
		2
		=================================

人的一生有多少时间是在休息中度过的？

时间流淌的太快, 于是乎进入了考试周, 加之这学期没去上过几门课，至于我竟然还在开学前的状态中。
J课一学期只看了一天的题型, 便匆匆考过。接下来还有4门, P课和H课的知识点较多, 时间也紧张。
早上考完J课, 天气正好, 和久病的Y去打网球。本想着回来便看书, 但是整个人很困, 又不去睡觉休息。
结果浏览网页中不知觉的流逝了一个下午, 等到翻开题目, 便开始犯困, 从5点半睡到8点半。
一没看数据结构和C++, 二没把复习的想法实现。

回过头来, 这件事情要是这样, 
回寝室, 洗澡, 午觉, H画图, 摘考点, 吃晚饭, 代码, 回信息。也许会好很多。
我不知疲倦的想要学点什么, 而忽视了人是会疲倦的本能。
因此, 将生活与工作的接口分离是有必要的。

先生活后工作。有些道理看似简单, 成为一种践行的观念对我来说还有点距离。
但我希望缓慢能做到。

一天24小时, 睡8小时的话, 有1/3在睡眠中度过。
剩下的时间对我来说是这样算的: 去大学里上水课像是一种休息, 但对我来说却无异于折磨, 老师在敷衍讲课, 学生在涣散玩手机, 所以它不是; 
打网球是种休息, 在传统的人比如我妈看来是在受罪; 
书和电影是种休息, 对那些更爱享受物质生活的人来说却很疲劳; 
亲密朋友约会吃饭是种休息, 也许我还没有到应酬这个词所描述的阶段; 跟恋人聊天约会是休息, 在温柔乡里让大脑重启; 
...等等很多。
我这个人有个特点就是, 对大家不爱做的事情, 乐此不疲, 对大家很热衷做的, 甚至是日常的事, 我却批判和提不起劲来。
这个也许是天性, 也许是习惯, 但总归已经形成, 已经形成的事情要去适应它, 不去用力过猛的扭转它。

休息是一种智慧。 
记得那回我迫切的想研究出offset空间域的算法, 但深陷在数据前后的相连性, 
无法去除循环的操作中, 连想三个晚上仍旧没想出, 最终还是牙龈淤血, 神经衰弱。
而那回, 当我顶着牙痛在小组内做事情的时候, S提醒我, 希特勒初期对德国的国力复兴是有很大贡献的,
但是他风光时身边的军官没能制止他, 让他去休息, 他也没能有这种知乎, 结果就是一场浩劫, 我们正享受着余波。

对休息也需要重构。
当结构不对, 走错方向, 需要重构。不是因为走错方向的问题, 迷失本身是美好的, 但在一定结构下的涌现才是这种迷失的前提, 而不是失控。

先生活后工作。

1, protected能否被实例对象访问

	>* 发现问题	
		重新实现Vector中, 要对ADT的access进行区别。
		protected能否被实例对象访问?
		protected能否被继承类访问?
	>* 尝试
		=================== source code ===========================
		class Base {
		private:
			int i = 0;
			void f_priv() {std::cout << "calling f_priv() in private" << std::endl;}
		protected:
			void f_prot() {std::cout << "calling f_prot() in protected" << std::endl;}
		public:
			void f() {
				std::cout << "calling f() in public" << std::endl;
				f_prot();
			}
		};
		
		class Derived : Base {
		public:
			void call_f_prot() {f_prot();}
			// void call_f_priv() {f_priv();}    // private不能被继承类直接访问
		};
		
		int main() {
			Base b;
			Derived d;
			// b.f_prot();      // protected成员不能被实例对象直接访问
			d.call_f_prot();    // 通过继承类的public成员, 访问基类的protected
			// d.call_f_priv();
			return 0;
		}
		=============================================================
		
	>* 特点
		protected不会被实例访问, 会被继承类在类中进行访问。
		
		希望用户不能访问到protected中的成员, 但继承类能够访问到。
		而private让用户和继承类都不能访问到, 只有友元能访问到。
---------------------------------------------------------------------------------------------

2, for循环语句的简单写法
	
	>* 发现问题
	for语句的三个表达式如何写?
	Vector(int c = DEAFAULT_CAPACITY, int s = 0, T v = 0)
	{_elem = new T[_capacity = c];
		for (_size = 0; _size < s; _elem[size++] = v)}     // 默认
		
	>* 利用for的参数
		for ( declaration-or-expression(optional) ; 
			declaration-or-expression(optional) ; 
			expression(optional) )
		=================== source code ============================
		const int s = 8;
		int size = 0;
		int elem[s] = {};
		/*
		for (size = 0; size < s; size++) {
			elem[size] = 2;
		}
		*/
		// 第三个参数, 递增size的同时, 给修改elem
		for (size = 0; size < s; elem[size++] = 2) {}
		// 第三个参数, 修改i的同时, 打印elem[i]对应的元素
		for (int i = 0; i < size; std::cout << elem[i++] << std::endl) {}
		============================================================
	>* 反思
		某变量会让循环条件false, 且该变量又是语句中的某一要素时候，一举两得。
----------------------------------------------------------------------------------------------

3, T const&, const T&, T& const, T const*, const T*, T* const 辨析
	
	>* 发现问题
		=================== source code ============================
		Vector(T* const A, Rank lo, Rank hi)           // 数组区间复制
		Vector(Vector<T> const& V, Rank lo, Rank hi)   // 向量区间复制
		============================================================
		对上述代码中的 Vector<T> const& V不理解, 为什么const& 跟在type之后? 它是否表达常量引用?

	>* 常量引用
		type const&, type& const之间是什么区别 ?
		先回答: 没区别。 但偏向写成前者, 能直接看出这是一个引用类型, 且为常量引用.
		
		让测试代码跑跑。
		=================== source code =============================
		int f() {
		int a = 0, b = 1;
		const int ca = 0, cb = 1;
		
		int& ref_a = a;      // ref_a是整数a的引用类型
		int* ptr_a = &a;     // ptr_a是指向整数a的指针
		const int* ptr_ca = &ca;           // ptr_ca是指向常量整型的指针
		const int* const cptr_ca = &ca;    // cptr_ca是指向常量整型的常量指针
		int const& cref_a = a;             // cref_a是对整型的常量引用?
		const int& cref_a_1 = ca;          // cref_a_1是对整型常量引用?
		// const int& const cref_a_2 = ca;    // 对整型常量的常量引用?
		// const int const& cref_a_3 = ca;    // 还是这样? 对整型常量的常量引用?
		// 引用不能duplicate const
		f1(cref_a);       // 将cref_a传入f1(), cref_a类型为 int const&匹配
		// cref_a++;      // read-only    // 两者都是常量引用
		// cref_a_1++;    // read-only
		
		// 引用指针
		int* const& cref_ptra = ptr_a;            // 对整型指针的常量引用
		// int const& cref_ptra_1 = ptr_a;        // 错误: 引用对象类型int*
		const int* const& cref_ptrca = ptr_ca;    // 对指向常量指针的常量引用
		// int* const& cref_ptrca_1 = ptr_ca;     // 错误: 引用对象类型const int*
		const int* const& cref_cptrca = cptr_ca;
		
		(*cref_ptra)+=1;          // cref_ptra整型指针的常量引用, 改变指向整型
		// (*cref_cptrca)+=1;     // ERROR: 无法通过引用, 改变指向常量的常量指针指向的整数(常量)
		}
		
		void f1(int const& ic) {
			std::cout << "calling f1()...\n";
		}
		=============================================================
		
		常量引用的写法. 所引用的对象类型为type
		(type) const& ref_t;
		// const&写在右边是因为侧重于表明其常量指针
		
		另外, 这一type可以是int, const int, int*, const int*等等
		
	>* 常量指针
		===================== source code ===========================
		int a = 0, b = 0, c = 0, d = 0;
		int* p_a = &a;                 // 指向int的指针
		// 指针地址可变, 指向的a可变
		(*p_a)++; p_a = &b;
		std::cout << "*p_a = " << *p_a << ", a = " << a << std::endl;
		const int* p_b = &b;          // 指向const int的指针
		// 指针地址可变, 指向的元素转换成const不可变
		// (*p_b)++;
		p_b = &c;
		std::cout << "*p_b = " << *p_b << ", b = " << b << std::endl;
		int* const cp_c = &c;          // 指向int的const指针
		// 指针地址不可变, 指向的元素可以变
		(*cp_c)++;
		// cp_c = &d;
		std::cout << "*cp_c = " << *cp_c << ", c = " << c << std::endl;
		// int const* cp_c1 = &c;         // 指向const int的指针, 仍采用上种方法
		const int* const cp_cd = &d;   // 指向const int的const指针
		// 指针地址不可变, 指向值不可变
		// (*cp_cd)++;
		// cp_cd = &a;
		std::cout << "*cp_cd = " << *cp_cd << ", d = " << d << std::endl;
		------------------------ ./a.out ---------------------------
		*p_a = 0, a = 1
		*p_b = 0, b = 0
		*cp_c = 1, c = 1
		*cp_cd = 0, d = 0
		============================================================
		T*               = &a;      // 指针
		const T*         = &ca;     // 指向常量的指针
		T* const         = &a;      // 常量指针, 指针地址不可变
		const T* const   = &ca;     // 指向常量的常量指针, 指向值和指针地址都不可变
		
	>* const_cast<type>();
		=======
		int b = 0;
		const int* p_b= &b;
		*(const_cast<int*>(p_b))+=1;   // 这种方式可以让b递增1
		// (*p_b)++                    // const_cast只是一个临时操作
		==========
		一方面可以去掉const的性质, 另外一方面又是临时的, 可以确保安全。
		我想这可能会用在, 绝大多数是const, 只有极少情况才会变的数据类型中。
	
	>*  最初的辨析
		T const& : 引用, T类型的常量引用, 该引用不会被修改
		const T& : 同上, 只是不同写法。现在偏向用上面那种
		T& const : 非法 
		T const* : 指针, 指向常量T的指针, const T*相同 
		const T* : 指针, 指向常量T的指针, 我偏向用这种
		T* const : 指针, 指向T的常量指针
---------------------------------------------------------------------------------------

凌晨睡不着看了一部电影叫<<看楚门的世界>>。

--------------------------------------------------------------------------------
1, 疑惑
	1) 戏中戏外的时间不同步
		戏内的楚门经历挫折, 徘徊折磨的这段时间大概有一个星期之多。而TV前的观众身处环境无太多变化。
		是否意味着，在这样一个世界时间也是可以改变的可能。
		大刘在三体中， 对宇宙历史时间的描述, 地球人出现了几次冬眠后被唤醒, 却被告知时间减少。
		在危机纪年, 世界变化很大, 中国成为超级大国。这就好像不难解释时间消失的问题....
	2) 关于梦醒
		长大生活在导演下, 歪书架, 红旗下, 以及梦的那些人, 
		梦何时醒? 梦醒需要多久? 梦醒的痛苦？

------------------------------------------------------------------------------------------
2, 观点
	1) 戏里戏外都在被安慰
		戏里的楚门被creator安排在一个normal的世界里生活。
		有趣的是, creator认为现世是肮脏病态的, 楚门生活的Seahaven应该是世界应该有的样子。
		而给了楚门Fiji梦的女孩却认为，正常的人不应该是囚犯、演员。
		他们都想用自己认为的方式安慰戏中的楚门。
		
		戏外在Fan Club聚众，昏沉同性恋夫妇, 洗澡油腻中年男人, 说出真相期待真爱的女主, 小镇警察, 导演以及制片人，
		通过秀来排解对现实的不满，不需要过多思考就安慰。
		创造, 沉迷, 打破, 遵守。屏幕前的我何尝不是呢？

	2) 构成生活看似真实性的一些元素
		说早安的幸福一家人。养了一条狗倒垃圾的邻居。打招呼的双胞胎路人。办公室的同事。
		交通, island boat, bus, car。给你插广告, 想要小孩的妻子。给你插广告, 拎着啤酒, 扯着道理，回忆往昔的朋友。
		独自吹风的海滩月光。童年回忆。母亲翻出的老旧照片。恋人的吻和留下的外套。工作日早晨的忙碌。
		神的安排。

	3) 二十世纪末的美国科技和科幻能力
		98年的片子以电视为主要媒介, 还出现电幕, 摄像头等设备。
		制片场中，用大型计算机, 内部交流用的设备，乌托邦主义者的形象，以及内部的装饰比较科幻, 让人不由想到1984中的监控场景。
		楚门的生活中汽车, 个人计算机, 不需接线员的电话, 录音机等都已经出现。
		当时都是不错的技术, 我感叹技术革新之快, 和当下环境中那些对技术的浮躁和推崇, 还有有些怀旧, 人到底需要多少的资源和科技呢?

	4) 如果对现有的生活不再眷恋
		除草。漂泊。割舍。接受。