如何编写高质量的代码-CSDN博客

一、代码的规范性

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

二、代码的完整性

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);
}

附:错误处理方法对比