一个函数最好只做一件事？未必！这是一个例子

  编程实践中，为了模块化设计，降低程序的复杂度，提高程序的可读性，通常设计一个函数时应尽可能简单，简单到只做一件事。然而，工程实践中，有时候受制于一些因素，如内存空间、程序执行效率等，迫使我们不得不打破“一个函数只做一件事”的规则。下面是一个例子：
  在嵌入式系统中，假设有一个100000行50列的矩阵A，需要计算矩阵A的转置乘以矩阵A。如果按照“一个函数只做一件事”的规则，那么我们需要编写计算矩阵转置的函数和矩阵相乘的函数，为了计算矩阵A的转置乘以矩阵A，调用函数计算矩阵的转置时，我们不得不额外定义一个占用内存空间很大的50行100000列的矩阵，这对于内存空间紧张的嵌入式系统，是一大问题。如果我们打破“一个函数只做一件事”的规则，定义一个函数同时计算矩阵的转置和矩阵相乘，这时不再需要额外定义一个很大的矩阵，不仅减少一次函数调用的开销，提高了程序执行效率，而且设计一个同时计算矩阵的转置和矩阵相乘的函数，函数依然简洁易读。事无绝对，切记勿墨守陈规！
  下面是示例代码：

#include 
//C = A' * B
void matrixTransposeAndMultiply(double *A, int rowsA, int colsA, double *B, int rowsB, int colsB, double *C)
{
        int i, j, k;

        // 计算转置乘以矩阵B的结果
        for (i = 0; i < colsA; i++)
        {
                for (j = 0; j < colsB; j++)
                {
                        C[i * colsB + j] = 0;
                        for (k = 0; k < rowsA; k++)
                        {
                                C[i * colsB + j] += A[k * colsA + i] * B[k * colsB + j];
                        }
                }
        }

        // 打印结果
        for ( i = 0; i < colsA; i++)
        {
                for (j = 0; j < colsB; j++) {
                        printf("%f\t", C[i * colsB + j]);
                }
                printf("\n");
        }
        printf("\n");

}

void main(void)
{
        double A[2 * 3] = { 1,2,5,4,7,2 }, B[2 * 1] = {4,5}, C[3 * 3], D[3 * 1];

        //C = A' * A
        matrixTransposeAndMultiply(A, 2, 3, A, 2, 3, C);

        //D = A' * B
        matrixTransposeAndMultiply(A, 2, 3, B, 2, 1, D);
}