1+2+3+.........+N 的n种解法

1+2+3+…+N的几种求法。

一、普通循环
这个就不多说了，普通循环得到答案

int GetValueByCir(size_t N)//普通循环
{
    int sum = 0;
    for (int idx = 1; idx <=N; idx++)
    {
        sum += idx;
    }
    return sum;
}

二、递归解决
通过控制递归条件递归求解

int GetValueByRec(size_t N)//递归版
{
    if (N==1)
         return 1;
    else 
        return N + GetValueByRec(N - 1);
}

三、用构造函数

定义一个类，类有两个静态的成员，一个count，一个sum
并初始化为0
每当调用构造函数时，count++，然后用sum加上当前的count值
如此，当我们需要加到N时，便可以生成N个对象
然后获取类内部的sum值即可
count、sum为私有成员，所以定义一个静态成员函数来返回结果。

class Test
{
public:
    Test()
    {
        count++;
        sum += count;
    }
    static int getsum()
    {
        return sum;
    }
public:
    static int count;
    static int sum;
};
int Test::count = 0;
int Test::sum = 0;
int main()
{
    Test *p = new Test[100];
    delete[] p;
    cout << Test::getsum();
}

四、用虚函数
这种做法也是递归的思想，创建一个数组，array[2]；里面存放 基类对象的指针，和派生类对象的指针，用来多态调用虚函数。代码如下

class AA;
AA* Array[2];//创建基类类型的指针数组
class AA
{
public:
    virtual size_t Sum(size_t n)
    {
        return 0;
    }
};

class BB :public AA
{
public:
    virtual size_t Sum(size_t n)
    {
        return Array[!n]->Sum(n - 1) + n;//当n=0时，非0就是1，调用基类的虚函数，结束递归开始返回
    }
};

int GetValueByVirtual(size_t n)
{
    AA a;
    BB b;
    Array[0] = &b;//基类指针指向派生类对象，Array[0]的类型是AA*
    Array[1] = &a;//基类指针指向基类对象，Array[1]的类型是AA*
    int value = Array[0]->Sum(n);
    return value;
}

void TestGetValueByVirtual()
{
    cout << GetValueByVirtual(5) << endl;
}
int main()
{
    TestGetValueByVirtual();
}

五、模板方式求
同理递归的方式。

template<size_t N>
size_t F()
{
    return N + F<N - 1>();
};
template<>//特化N，1的时候结束递归
size_t F<1>()
{
    return 1;
};
void TestGetValueByTemplate()
{
    cout << F<1000>() << endl;
}