#include <stdio.h>
#include <stdlib.h>

char * favorite_fruit1(void);
char * favorite_fruit2(void);
void favorite_fruit3(char **);
int main(void) {
    char * fruit1 = favorite_fruit1();
    printf("%s\n", fruit1);

    char * fruit2 = favorite_fruit2();
    printf("%s\n", fruit2);

    char * fruit3 = NULL;
    favorite_fruit3(&fruit3);
    printf("%s\n", fruit3);

    printf("------END of CODE------");
    return EXIT_SUCCESS;
}
char * favorite_fruit1(void){
    char deciduous[] = "apple";
    return deciduous;
}
char * favorite_fruit2(void){
    static char deciduous[] = "apple";
    return deciduous;
}
void favorite_fruit3(char ** fruit){
    static char deciduous[] = "apple";
    *fruit = deciduous;
}

favorite_fruit1很明显会出现问题，原因是因为char deciduous[]是局部变量，在函数调用返回后，就释放了。

favorite_fruit2因为使用了static，而static限定了变量被保存在数据段（data segment）中，它的声明周期同程序一样长。所以不会出错。

favorite_fruit3是另一种有效的写法，其原理同2。

Algorithms.h

#pragma once

#include <iostream>

class Algorithms
{
public:
    Algorithms(void);
    ~Algorithms(void);

public:
    template <typename T>
    static void QuickSort(T* arr, size_t min, size_t max);
private:
    template <typename T>
    static size_t qsort_helper_partition(T* arr, size_t min, size_t max);
    template <typename T>
    static inline void swap(T* arr, size_t x, size_t y);
};

template <typename T>
void Algorithms::QuickSort(T* arr, size_t min, size_t max)
{
    if(min >= max || max == 0 - 1) return;
    size_t p = qsort_helper_partition(arr, min, max);

    QuickSort(arr, min, p - 1);
    QuickSort(arr, p + 1, max);
}

template <typename T>
size_t Algorithms::qsort_helper_partition(T* arr, size_t min, size_t max)
{
    T cmp = arr[min];
    int i = min + 1, j = max;
    while(true)
    {
        while(cmp < arr[i])
            ++i;
        while(arr[j] < cmp)
            --j;
        if(i >= j) break;

        swap(arr, i, j);
    }
    swap(arr, min, j);
    return j;
}

template <typename T>
void Algorithms::swap(T* arr, size_t x, size_t y)
{
    T tmp = arr[x];
    arr[x] = arr[y];
    arr[y] = tmp;
}

用法：（顺便有标准库的排序法，当然只是调一下，没有什么可说的了）

#include "Algorithms.h"
#include <iostream>
#include <vector>
#include <algorithm>

int _tmain(int argc, _TCHAR* argv[])
{
    int arr[] = {4, 8, 3, 7, 1, 5, 6, 2};

    for(size_t i = 0; i != 8; ++i)
    {
        std::cout<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    Algorithms::QuickSort(arr,0, 7);

    for(size_t i = 0; i != 8; ++i)
    {
        std::cout<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    std::vector<int> vec;
    vec.push_back(3);
    vec.push_back(1);
    vec.push_back(4);
    vec.push_back(1);
    vec.push_back(7);
    vec.push_back(6);

    for(std::vector<int>::iterator iter = vec.begin();
        iter != vec.end(); ++ iter)
    {
        std::cout<<*iter<<" ";
    }
    std::cout<<std::endl;

    std::sort(vec.begin(), vec.end());

    for(std::vector<int>::iterator iter = vec.begin();
        iter != vec.end(); ++ iter)
    {
        std::cout<<*iter<<" ";
    }
    std::cout<<std::endl;

    return 0;
}