上一篇：https://blog.csdn.net/weixin_42523774/article/details/105619681

· 为何简化逻辑结构单独作为一篇阐述？
· 如果代码逻辑复杂，如何才能理清代码中的浮云，显现出其最原本的逻辑，为后续修改逻辑来铺平道路。这就需要一系列的手法，我称之为技能基础。而这些技能遵循二八法则，学到这20%，使用会占到80%。因此学习这些手法是很有必要的。
· 由于重构用到了很多面向对象的思维，如果对C语言面向对象编程不熟悉，请查看这篇《学会C语言面向对象编程，弄清面向对象实质。》
· 首先介绍一下四个名词的含义：
（1）提炼——增加代码逻辑的层次，增加代码逻辑的中间层；
（2）内联——减少代码逻辑的层次，干掉代码逻辑的中间层；
（3）组合——将代码放到一起，增加相关性；
（4）拆分——将代码分开放置，减少耦合。
· 下面逐步介绍各种方法：

1. 提炼函数

· 将诸多的代码提炼成一个函数，那么何时需要提炼呢？
· 如果你要花一段时间来理解代码的意图，你就需要将它提炼到一个函数中，让人一看到这个函数就知道它在做什么。
· 函数不要太大，我的经验是超过6行的函数就感觉有点多了，你可能会担心短函数会导致大量的函数调用，而影响性能，
· 但是现在短函数常常能让编译器的优化功能运转更为良好，因此不用过多担心性能问题。
· 小函数需要有好名字，你可以从注释中得到提示。
· 范例：

（1）无局部变量：这部分最简单，就是把一段无影响的功能提出来

比如有一行异常打印：

printf("error happened in func!\n");

提炼成：

void print_error(void) {
	printf("error happened in func!\n");
}

（2）有局部变量：

比如我想把这个func提出来，作为一个参数输入，就可以这样；
提炼成：

void print_error(const char *func_name) {
	printf("error happened in %s!\n", func_name);
}

（3）对局部变量再赋值：

· 这种情况就是函数修改的变量，需要在函数外使用；我们可以把参数作为输入，然后用返回值返回；
· 比如上面的打印函数需要记录打印出错的次数：
提炼成：

int print_error(const char *func_name) {
	static count = 0;
	printf("error %d happened in %s!\n", ++count, func_name);
	return count;
}

· 如果需要返回的函数参数有多个，我建议可以用多个函数来提炼，保证只返回一个，如果实在是需要多个，建议通过封装对象(struct)的方式范返回。

2.内联函数

· 内联函数就是提炼函数的反向重构。
· 当函数的内部代码和函数名称同样清晰易读，也可能是你重构了函数实现，使其内容和其名称同样清晰时，这样就建议你直接使用其中的代码。
· 间接性可能带来帮助，但是非必要的间接性总是让人不舒服。通过内联手法，可以找出有用的间接层，也可以将无用的间接层去除。
做法：
找出函数的所有调用点，逐个替换。
范例：

（1）简单情况

int rating(struct Driver_info aDriver) {
	return moreThanFiveLateDeliveries(aDriver) ? 2 : 1;
}
int moreThanFiveLateDeliveries() {
	return aDriver.numberOfLateDeliveries > 5;
}

内联为：

int rating(struct Driver_info aDriver) {
	return aDriver.numberOfLateDeliveries > 5? 2 : 1;
}

（2）复杂情况：

当需要移出的函数内容很复杂时，你就需要"剪切-粘贴-调整"来进行，当调用函数众多，则需要调整一次就测试一次；
如果你遇到了麻烦，就意味着需要使用更精细的重构手法：搬移语句到调用者（217）。

3. 提炼变量

· 有时表达式可能非常难以阅读，这时，局部变量可以帮助我们将表达式分解为比较容易管理的形式，让我们理解这部分的逻辑是干什么的。
· 命名：如果考虑使用提炼变量，就意味着我要给代码中的一个表达式命名。
· 如果这个名字只在当前函数中有意义，提炼变量是个不错的选择。
· 如果这个命名，在更宽的上下文中，我就会考虑将其暴露出来，通常以函数的形式。
范例：

（1）简单计算提取

int price(struct goods order) {
	//price is base price - quantity discount + shipping
	return order.quantity * order.itemPrice - 
	max(0, order.quantity - 500) * order.itemPrice * 0.05 +
	min(order.quantity * order.itemPrice * 0.1, 100);
}

提炼出basePrice为：

int price(struct goods order) {
	//price is base price - quantity discount + shipping
	const int basePrice = order.quantity * order.itemPrice;
	return basePrice - max(0, order.quantity - 500) * order.itemPrice * 0.05 +
	min(basePrice * 0.1, 100);
}

再提炼出quantity discount为：

int price(struct goods order) {
	//price is base price - quantity discount + shipping
	const int basePrice = order.quantity * order.itemPrice;
	const quantityDiscount = max(0, order.quantity - 500) * order.itemPrice * 0.05;
	return basePrice - quantityDiscount + min(basePrice * 0.1, 100);
}

最后提炼出shipping为，修改之后，注释也就不需要了：

int price(struct Order order) {
	const int basePrice = order.quantity * order.itemPrice;
	const quantityDiscount = max(0, order.quantity - 500) * order.itemPrice * 0.05;
	const shipping = min(basePrice * 0.1, 100);
	return basePrice - quantityDiscount + shipping;
}

（2）类对象提取

· 同样的内容，比如在类对象中，可以如下操作：
· C语言面向对象操作，见另一篇文章《学会C语言面向对象编程，弄清面向对象实质。》
顺带介绍一下：

struct Order {
	int data;
	struct OrderOperations *orderOp;
};
struct OrderOperations {
	int (*price)(struct Order *order);
};
int price(struct Order *order) {
	//price is base price - quantity discount + shipping
	return order->quantity * order->itemPrice - 
	max(0, order->quantity - 500) * order->itemPrice * 0.05 +
	min(order->quantity * order->itemPrice * 0.1, 100);
}
struct Order* alloc_Order(void) {
#define ORDER_DEFAULT_DATA 0
	static struct OrderOperations orderOp = {
		.price = price,
	};
	struct Order* order = (struct Order* )malloc(sizeof(struct Order));
	order->orderOp = orderOp;
	order->data = ORDER_DEFAULT_DATA;
	return order;
}
int main(int argc, char *argv[]) {
	struct Order* order = alloc_Order();
	printf("order price is %d.\n", order->orderOp->price(order));
	return 0;
}

提炼为：

struct OrderOperations {
	int (*getPrice)(struct Order *order);
	int (*getBasePrice)(struct Order *order);
	int (*getQuantityDiscount)(struct Order *order);
	int (*getShipping)(struct Order *order);
};
int getBasePrice(struct Order *order) {
	return order->quantity * order->itemPrice;
}
int getQuantityDiscount(struct Order *order) {
	return max(0, order->quantity - 500) * order->itemPrice * 0.05;
}
int getShipping(struct Order *order) {
	return min(order->quantity * order->itemPrice * 0.1, 100);
}
int getPrice(struct Order *order) {
	return order->getBasePrice(order) - order->getQuantityDiscount(order) + order->getShipping(order);
}
struct Order* alloc_Order(void) {
#define ORDER_DEFAULT_DATA 0
	static struct OrderOperations orderOp = {
		.getPrice = getPrice,
		.getBasePrice = getBasePrice,
		.getQuantityDiscount = getQuantityDiscount,
		.getShipping = getShipping,
	};
	struct Order* order = (struct Order* )malloc(sizeof(struct Order));
	order->orderOp = orderOp;
	order->data = ORDER_DEFAULT_DATA;
	return order;
}
int main(int argc, char *argv[]) {
	struct Order* order = alloc_Order();
	printf("order price is %d.\n", order->orderOp->price(order));
}

· 在一个简单的对象中暂时看不出太明显的好处，但是当这个对象很大的时候，如果找出了可以共用的行为，赋予它独立的概念，起个好名字，对于使用对象的人来说会很有帮助。

4.内联变量

· 虽然有时候，变量可以给表达式提供更有意义的名字；但是有时候，这个名字并不比表达式本身更有表现力，甚至妨碍重构附近的代码，这时就该通过内联手法消除变量。
范例：

int basePrice = anOrder.basePrice;
return (basePrice > 1000);

内联为：

return anOrder.basePrice > 1000;

5.改变函数声明

· 函数是我们将程序拆成小块的主要方式，而这中方式其中最重要的当属函数的名字。一个好名字能让我一眼看出函数的用途，而不必查看其实现代码。
· 如果看到函数名字满足不了上面的要求，一旦发现更好的名字，就得尽快给函数改名。对于函数的参数列表也是一样的道理。对函数的参数也是同理。
这里说的改变函数声明，包括函数改名，函数参数改名，函数参数增减等项。

1）简单做法（可以一步到位）

直接将函数修改为新的函数声明，然后测试。
如果你既想修改函数名，又想添加参数，最好分2步做。

2）迁移式做法（不能做到一步到位）

.1.如果有必要的话，可以先对函数体内部进行重构，使得后面的提炼步骤易于开展；
.2.先提炼函数，将函数提炼成一个新的函数,如果想沿用旧函数名，建议先给新函数起一个便于查找的临时名字；
.3.如果需要添加参数，就用之前的方式添加；
.4.测试；
.5.对旧函数使用内联函数，释放函数中的内容；
.6.如果新函数使用了临时名字，在此使用改变函数声明将其改回来。

范例：

（1）函数改名（简单做法）

int circum(int radius) {
	return 2 * PI * radius;
}

修改成：

int circumference(int radius) {
	return 2 * PI * radius;
}

（2）函数改名（迁移式做法）

int circum(int radius) {
	return 2 * PI * radius;
}

修改成：

int circum(int radius) {
	return circumference(radius);
}
int circumference(int radius) {
	return 2 * PI * radius;
}

然后测试，通过后使用内联函数手法。

（3）添加参数

迁移式做法类似，不在重复介绍。

（4）把参数修改为属性

迁移式做法类似，不在重复介绍。

6.封装变量

· 数据的重构相对于函数要麻烦得多。
· 如果想要搬移一处被广泛使用的数据，最好的办法是先以函数的形式封装所有对数据的访问。
· 对于所有的可变数据，只要它的作用域超过单个函数，我就会将其封装起来，只允许通过函数访问。数据的作用域越大，封装就越重要。处理遗留代码时，一旦需要修改或增加使用可变数据的代码，我就会借机把这份数据封装起来，从而避免继续加重耦合。面向对象的方法如此强调对象的数据应该保持私有，背后也是同样的原理。
· 相比于封装数据，不可变的数据更重要，不可变让大家可以放心使用旧数据，不用做搬移，不用担心代码失效。

范例：

（1）全局变量

赋值：

struct Owner defaultOwner = {
	.firstName = "Martin",
	.lastName = "Fowler",
};

使用:

owner = defaultOwner;

更新：

defaultOwner.firstName = "Rebecca";
defaultOwner.lastName = "Parsons";

· 重构第一步：封装成函数
· 获取值的时候，建议不用指针，返回的内容就是副本，这样原来数值不会被修改。获取时建议不加get。

struct Owner defaultOwner(void) {
	return defaultOwner;
}
void setDefaultOwner(struct Owner newOwner) {
	defaultOwner = newOwner;
	return;
}

· 重构第二步：修改变量限制
然后可以将原来的变量增加限制，比如加上 static 限制在此文件中使用，如果做不到，建议将变量取一个有意义有难看的名字。
例如 __privateOnly_defaultOwner 。本次将其改为

static struct Owner defaultOwnerData = {
	.firstName = "Martin",
	.lastName = "Fowler"
};

· 重构第三步：将其封装为一个对象，但是C语言不支持，因此封装成结构体是唯一选择。前面已经做好。

7.变量改名

· 好的命名是整洁编程的核心。变量名可以很好的解释这段程序在干啥——如果名字起的好的话。
· 使用范围越广，名字的好坏就越重要。
· 我习惯将变量的类型信息也放进名字里面，我的类型对于的名字前缀表：

char - c，
unsigned char - uc， 
short - s,
unsigned short - us
int - i,
unsigned int - ui,
struct - t或对应的类型名字,
union - u,
指针 - p,
enum - e,
数组 - a,
float - f，
double - d，

· 如果变量被广泛使用，建议使用封装变量的方法，将其封装起来。
· 常量改名，通常先复制这个常量，用新常量复制给旧的常量，这样删除就常量时会稍微快一点。
范例：此处前面变量封装例子类似，就不做此范例。

8.引入参数对象

· 当同一组数据项经常同时出现在多个函数的参数列表中时，我喜欢代之以一个数据结构，将其组合起来。
· 这件事情的价值，在于将数据项之间关系变得明晰，而进一步围绕该结构来捕捉共用行为，这个结构将提升为新的抽象概念。这个力量是强大的。
做法：
· 在该函数增加一个创建的数据结构的参数，然后一个一个的将参数项移到这个结构中，记得每一步都要保证测试通过。
范例：

int  readingsOutsideRange(int station, int min, int max) {
	return (station < min)? min : ((station > max)? max: station);
}

首先逐步重构为：

struct NumberRange {
	int station;
	int min;
	int max;
};
int  readingsOutsideRange(struct NumberRange range) {
	return (range.station < range.min)? range.min : ((range.station > range.max)? range.max: range.station);
}

对此结构中的数据提取最好封装成函数：

struct NumberRange {
	int station;
	int min;
	int max;
};
int min(struct NumberRange *range) {
	return range->min;
}
int max(struct NumberRange *range) {
	return range->max;
}
int  readingsOutsideRange(struct NumberRange range) {
	return (range.station < min(&range))? min(&range) : ((range.station > max(&range) )? max(&range): range.station);
}

9.函数组合成类

将数据组合起来，将数组的操作通过函数也放进来。

· 函数组合成类是将函数重新组织的一种方式，当一组函数形影不离地操作同一块数据，这是就该组件一个类了。一般来说，类可以提供一套环境，可以让我们的函数少传许多参数，而一个对象也可以更方便的传递给系统的其他部分。只是在C语言中，没有面向对象的支持，但是仍然可以将其组合成结构体使用。
做法：
（1）运用封装记录对多个函数共用的数据记录加以封装；
（2）对于使用该记录结构的每个函数，运用搬移函数将其移入新类；
（3）用以处理数据记录的逻辑，可以用提炼函数的方法提炼出，并移入新类。
范例：
· 延续运用第8节中的例子，上一节中使用了如下代码

struct NumberRange {
	int station;
	int min;
	int max;
	int (*getMin)(struct NumberRange *range);
	int (*getMax)(struct NumberRange *range);
};
int min(struct NumberRange *range) {
	return range->min;
}
int max(struct NumberRange *range) {
	return range->max;
}
struct NumberRange* allocNumberRange(void) {
    static struct OrderOperations orderOp = {
        .getMin = min,
		.getMax = max,
    };
    struct NumberRange* range = (struct NumberRange* )malloc(sizeof(struct NumberRange));
    range->min = ORDER_DEFAULT_DATA;
    range->max = ORDER_DEFAULT_DATA;
    range->getMin = min;
	range->getMax = max;
    return range;
}

int readingsOutsideRange(struct NumberRange *range) {
	return (range->station < min(range))? min(range) : ((range->station > max(range) )? max(range): range->station);
}
int main(void **argc,void *argv[]) {
	struct NumberRange* range = allocNumberRange();
	printf("OutsideRange is %d.\n", readingsOutsideRange(range));
}

· 我想把 readingsOutsideRange函数搬移到 NumberRange 的内部；

struct NumberRange {
    int station;
    int min;
    int max;
    int (*getMin)(struct NumberRange *range);
    int (*getMax)(struct NumberRange *range);
    int (*readingsOutsideRange)(struct NumberRange *range);/*添加*/
};
static int min(struct NumberRange *range) {
    return range->min;
}
static int max(struct NumberRange *range) {
    return range->max;
}
static int _readingsOutsideRange(struct NumberRange *range) {
    return (range->station < min(range))? min(range) : ((range->station > max(range) )? max(range): range->station);
}
struct NumberRange* allocNumberRange(void) {
#define ORDER_DEFAULT_DATA 1
    struct NumberRange* range = (struct NumberRange* )malloc(sizeof(struct NumberRange));
    range->min = ORDER_DEFAULT_DATA;
    range->max = ORDER_DEFAULT_DATA;
    range->getMin = min;
    range->getMax = max;
    range->readingsOutsideRange = _readingsOutsideRange;/*添加*/
    return range;
}


int main(void **argc,void *argv[]) {
    struct NumberRange* range = allocNumberRange();
    range->station = 3;
    printf("OutsideRange is %d.\n", range->readingsOutsideRange(range));/*修改*/
}

10.函数组合成变换

将数据组合起来，将各种函数的操作集合成一个函数。

· 我们经常会将数据"喂"给一个程序，让它产生很多派生信息。这些派生数据可能在多个不同的地方用到，而计算的逻辑也就会在多个地方重复。
我更愿意将所有计算派生数据的逻辑收拢到一处，这样可以在固定的地方找到和更新这些逻辑，避免重复。
· 本方案的替代方案是函数组合成类，如何判断使用哪一个呢？如果代码中会对源数据进行更新，那么使用类要好得多。使用变换的话，源数据更新之后会导致与派生数据不一致。
使用方式：
（1）创建一个变化函数，入参是需要变换的记录，并直接返回记录的值。
（2）选择一块逻辑，将主体移入该函数中，并将结果添加到输出记录中。
（3）测试并重复上述步骤。

范例：
延续使用第8节的例子，用函数组合成变换的方式进行重构。

struct NumberRange {
	int station;
	int min;
	int max;
};
int min(struct NumberRange *range) {
	return range->min;
}
int max(struct NumberRange *range) {
	return range->max;
}
int  readingsOutsideRange(struct NumberRange range) {
	return (range.station < min(&range))? min(&range) : ((range.station > max(&range) )? max(&range): range.station);
}
/*新增一个获取范围宽度的函数*/
int  readingsRangeWidth(struct NumberRange range) {
	return max(&range) - min(&range);
}

· 首先，readingsOutsideRange 和 readingsRangeWidth 的两个函数是获取的扩展信息，首先将扩展信息放入struct中，然后创建一个计算扩展信息的函数，并逐步把函数移到这里。

struct NumberRange {
	int station;
	int min;
	int max;
	/*扩展信息*/
	int outsideRange;
	int rangeWidth;
};

struct NumberRange enrichReadings(struct NumberRange range) {
	range.outsideRange = readingsOutsideRange(range);
	range.rangeWidth = readingsRangeWidth(range);
	return range;
}

· 这里要记住，不能一步到位，没改一步都要测试，调用的位置要非常仔细。

11.拆分阶段

学会了组合，也要学会拆分。每当同一块代码在同时处理两件不同的事情，我就想将其拆分成独自的模块，这是运用解耦的思想。因为到了要修改的时候，我就可以单独处理每个主题而不用考虑两个不同的主题。
最简洁的方法：将一大块行为分成顺序执行的两个阶段。如果数据不符合要求，你可能需要先对输入数据做调整。
做法：
（1）将第二阶段的代码提炼成独立的函数，并测试。（假设只有2段需要拆分的逻辑）
（2）引入一个中转数据结构，将其作为参数添加到提炼的新函数参数列表中，并测试。
（3）判断入参是否被第一阶段代码使用，是就将入参逐步搬移到中转数据结构中，注意每次搬移都要测试一次；
（4）对第一阶段的代码运用提炼函数，将提炼出的函数返回中转数据结构。
范例：
这里有一个计算价格的函数：

struct Product {
	int basePrice;
	int discountThreshold;
	int discountRate;
};
struct ShippingMethod {
	int discountedFee;
	int feePerCase;
	int discountThreshold;
};
int priceOrder(struct Product product, int quantity, struct ShippingMethod shippingMethod) {
	const int basePrice = product.basePrice * quantity;
	const int discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;
	const int shippingPerCase = (basePrice > shippingMethod.discountThreshold)? shippingMethod.discountedFee : shippingMethod.feePerCase;
	const int shippingCost = quantity * shippingPerCase;
	int price = basePrice - discount + shippingCost;
	return price;
}

· 该函数中有点混乱,需要逐步拆分,首先拆出shipping配送相关的部分；

int priceOrder(struct Product product, int quantity, struct ShippingMethod shippingMethod) {
	int basePrice = product.basePrice * quantity;
	int discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;
	int price = applyShipping(basePrice, shippingMethod, quantity, discount);
	return price;
}
int applyShipping(int basePrice, struct ShippingMethod shippingMethod, int quantity, int discount) {
	int shippingPerCase = (basePrice > shippingMethod.discountThreshold)? shippingMethod.discountedFee : shippingMethod.feePerCase;
	int shippingCost = quantity * shippingPerCase;
	int price = basePrice - discount + shippingCost;
	return price;
}

· 增加一个结构，审视各个参数，将函数参数逐步放入。shippingMethod第一阶段没用到，可以不放，quantity这个参数可以继续选择放不放，我还是想尽可能放进去，得到如下代码。

struct PriceData {
	int basePrice;
	int quantity;
	int discount;
};
int priceOrder(struct Product product, int quantity, struct ShippingMethod shippingMethod) {
	int basePrice = product.basePrice * quantity;
	int discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;
	struct PriceData priceData = {basePrice, quantity, discount};/*新建结构体*/
	int price = applyShipping(priceData, shippingMethod/*, basePrice, quantity, discount*/);
	return price;
}
int applyShipping(struct PriceData priceData, struct ShippingMethod shippingMethod/*, int basePrice, int quantity, int discount*/) {
	int shippingPerCase = (priceData.basePrice > shippingMethod.discountThreshold)? shippingMethod.discountedFee : shippingMethod.feePerCase;
	int shippingCost = priceData.quantity * shippingPerCase;
	int price = priceData.basePrice - priceData.discount + priceData.shippingCost;
	return price;
}

· 最后将第一阶段也组合成一个函数：

struct PriceData {
	int basePrice;
	int quantity;
	int discount;
};
/*新的函数，计算出priceData*/
struct priceData caculatePriceData(struct Product product, int quantity) {
	struct PriceData priceData;
	priceData.basePrice = product.basePrice * quantity;
	priceData.discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;
	priceData.quantity = quantity;
	return priceData;
}
int priceOrder(struct Product product, int quantity, struct ShippingMethod shippingMethod) {
	/*int basePrice = product.basePrice * quantity;
	int discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;*/
	struct PriceData priceData = caculatePriceData(product, quantity);{basePrice, quantity, discount};/*新建结构体*/
	int price = applyShipping(priceData, shippingMethod/*, basePrice, quantity, discount*/);
	return price;
}
int applyShipping(struct PriceData priceData, struct ShippingMethod shippingMethod/*, int basePrice, int quantity, int discount*/) {
	int shippingPerCase = (priceData.basePrice > shippingMethod.discountThreshold)? shippingMethod.discountedFee : shippingMethod.feePerCase;
	int shippingCost = priceData.quantity * shippingPerCase;
	int price = priceData.basePrice - priceData.discount + priceData.shippingCost;
	return price;
}

最后去掉注释，整理下，得最终结果。


struct PriceData {
	int basePrice;
	int quantity;
	int discount;
};
int priceOrder(struct Product product, int quantity, struct ShippingMethod shippingMethod) {
	struct PriceData priceData = caculatePriceData(product, quantity)；
	return applyShipping(priceData, shippingMethod/*, basePrice, quantity, discount*/);
}
/*第一阶段计算出priceData*/
struct priceData caculatePriceData(struct Product product, int quantity) {
	struct PriceData priceData;
	priceData.basePrice = product.basePrice * quantity;
	priceData.discount = max(quantity - product.discountThreshold, 0) * product.basePrice * product.discountRate;
	priceData.quantity = quantity;
	return priceData;
}
/*第二阶段计算出price*/
int applyShipping(struct PriceData priceData, struct ShippingMethod shippingMethod) {
	int shippingPerCase = (priceData.basePrice > shippingMethod.discountThreshold)? shippingMethod.discountedFee : shippingMethod.feePerCase;
	int shippingCost = priceData.quantity * shippingPerCase;
	return priceData.basePrice - priceData.discount + priceData.shippingCost;
}

12. 总结

· 本文介绍了简化逻辑结构的各种方法，主要思想就是用 2 对武器 {提炼，内联}，{组合，拆分}。就像2把快刀，将程序修剪得整整齐齐。这2对武器大部分情况下都是够用的了。
· 学到东西，就要去实践，实践中出现的问题，也请大家给我留言反馈，谢谢！

重构C语言版(二) 技能基础篇：简化逻辑结构

1. 提炼函数

（1）无局部变量：这部分最简单，就是把一段无影响的功能提出来

（2）有局部变量：

（3）对局部变量再赋值：

2.内联函数

（1）简单情况

（2）复杂情况：

3. 提炼变量

（1）简单计算提取

（2）类对象提取

4.内联变量

5.改变函数声明

1）简单做法（可以一步到位）

2）迁移式做法（不能做到一步到位）

（1）函数改名（简单做法）

（2）函数改名（迁移式做法）

（3）添加参数

（4）把参数修改为属性

6.封装变量

范例：

（1）全局变量

7.变量改名

8.引入参数对象

9.函数组合成类

10.函数组合成变换

11.拆分阶段

12. 总结

芯片产业管理和营销指北（1）—— 产品线经理主要职能

记一次疑似JVM内存泄漏的排查过程

弄懂linux文件，這一篇就夠了。

yaffs2的Linux架構

重構C語言版(一) 概念原則篇

重構C語言版(二) 技能基礎篇：簡化邏輯結構

學會C語言面向對象編程，弄清面向對象實質。

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

重构C语言版(二) 技能基础篇： 简化逻辑结构

1. 提炼函数

（1）无局部变量：这部分最简单，就是把一段无影响的功能提出来

（2）有局部变量：

（3）对局部变量再赋值：

2.内联函数

（1）简单情况

（2）复杂情况：

3. 提炼变量

（1）简单计算提取

（2）类对象提取

4.内联变量

5.改变函数声明

1）简单做法（可以一步到位）

2）迁移式做法（不能做到一步到位）

（1）函数改名（简单做法）

（2）函数改名（迁移式做法）

（3）添加参数

（4）把参数修改为属性

6.封装变量

范例：

（1）全局变量

7.变量改名

8.引入参数对象

9.函数组合成类

10.函数组合成变换

11.拆分阶段

12. 总结

重构C语言版(二) 技能基础篇：简化逻辑结构