如何编写高质量的代码

一、代码的规范性

清晰的书写、清晰的布局、合理的命名

二、代码的完整性

1.通过功能测试、边界测试、负面测试保证代码完整性

2.采用合理的错误处理方法：a、通过函数返回值告诉调用者是否出错 b、通过全局变量设置相应标志提醒调用者出错 c、通过抛出异常方式检测程序中的错误

例题：实现函数double Power(double base,int exponent),求base的exponent次方，不得使用库函数，同时不需要考虑大数问题。

bool g_InvalidInpt = false;
double Power(double base, int exponent)
{
g_InvalidInput = false;//通过全局变量处理程序中的错误

if(equal(base, 0.0) && exponent < 0)
{
g_InvalidInput = true;//底小于或等于0，此时标识为错误输入
return 0.0;
}
//底大于0，幂小于0的计算方式
unsigned int absExponent = (unsigned int)(exponent);
if(exponent < 0)
absExponent = (unsigned int)(-exponent);

double result = PowerWithUnsignedExponent(base, absExponent);
if(exponent < 0)
result = 1.0 / result;
return result;
}
//底大于0，幂大于0时的计算方式1
/*
double PowerWithUnsignedExponent(double base, unsigned int exponent)
{
double result = 1.0;
for(int i = 1; i <= exponent; ++i)
result *= base;
return result;
}
*/

//底大于0，幂大于0时的计算方式2
double PowerWithUnsignedExponent(double base, unsigned int exponent)
{
if(exponent == 0) return 1;
if(exponent == 1) return base;
double result = PowerWithUnsignedExponent(base, exponent >> 1);
//偶数时
result *= result;
//奇数时
if((exponent & 0x1) == 1)
result *= base;
return result;
}

//判断底是否等于0，切勿用num1==num2这样的方式直接比较大小，因为double存在精度问题
bool equal(double num1, double num2)
{
if((num1 - num2 > -0.0000001)
&& (num1 - num2 < 0.0000001))
return true;
else
return false;
}

底大于0，幂大于0的计算方式2参考的公式如图:



三、代码的鲁棒性

鲁棒性是指程序能够判断输入是否合乎规范要求，并对不合理的输入予以合理的处理。

例题：定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。

ListNode* ReverseList(ListNode* pHead)
{
ListNode* pReversedHead = NULL;
ListNode* pNode = pHead;
ListNode* pPrev = NULL;
while(pNode != NULL)
{
ListNode* pNext = pNode->m_pNext;

if(pNext == NULL)
pReversedHead = pNode;

pNode->m_pNext = pPrev;//将i的下一结点变为其前一结点
pPrev = pNode;//变更pPrev，进行下次循环判断
pNode = pNext;//为了防止链表在结点i处断裂，把结点j保存下来（变更pNode，进行下次循环判断）
}
return pReversedHead;
}
// ====================测试代码====================
ListNode* Test(ListNode* pHead)
{
printf("The original list is: \n");
PrintList(pHead);
ListNode* pReversedHead = ReverseList(pHead);
printf("The reversed list is: \n");
PrintList(pReversedHead); return pReversedHead;
}
// 输入的链表有多个结点
void Test1()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(2);
 ListNode* pNode3 = CreateListNode(3);
   ListNode* pNode4 = CreateListNode(4);
 ListNode* pNode5 = CreateListNode(5);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
   ConnectListNodes(pNode3, pNode4);
   ConnectListNodes(pNode4, pNode5);
ListNode* pReversedHead = Test(pNode1);
DestroyList(pReversedHead);}
// 输入的链表只有一个结点
void Test2()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pReversedHead = Test(pNode1);
DestroyList(pReversedHead);
}
// 输入空链表
void Test3()
{
Test(NULL);
}

附:错误处理方法对比