根据/proc/meminfo对空闲内存进行占用

#include <stdio.h>

#include <sys/sysinfo.h>
#include <linux/kernel.h>     /* 包含sysinfo结构体信息*/
#include <unistd.h>

#include <string>
#include <iostream>
#include <fstream>
#include <map>
#include <vector>
#include <assert.h>
#include <stdlib.h>
using namespace std;

///////////////////////////////////////////////////
// Item Names which should be corresponded to the enum below restrictly
const char * ItemCheckName[] =
{
    "MemTotal",
    "MemFree",
    "Buffers",
    "Cached"
};

enum ITEMCHECKNAME
{
    MEMTOTAL = ,
    MEMFREE,
    BUFFERS,
    CACHED
};

const int INVALID_VALUE = -;
const char* MEM_INFO_FILE_NAME = "/proc/meminfo";
bool isDebugging = false;
//////////////////////////////////////////////////////    

string trim(const string& str)
{
    string::size_type pos = str.find_first_not_of(' ');
    if (pos == string::npos)
    {
        return str;
    }
    string::size_type pos2 = str.find_last_not_of(' ');
    if (pos2 != string::npos)
    {
        return str.substr(pos, pos2 - pos + );
    }
    return str.substr(pos);
}

int split(const string& str, vector<string>& ret_, string sep = ",")
{
    if (str.empty())
    {
        return ;
    }

    string tmp;
    string::size_type pos_begin = str.find_first_not_of(sep);
    string::size_type comma_pos = ;

    while (pos_begin != string::npos)
    {
        comma_pos = str.find(sep, pos_begin);
        if (comma_pos != string::npos)
        {
            tmp = str.substr(pos_begin, comma_pos - pos_begin);
            pos_begin = comma_pos + sep.length();
        }
        else
        {
            tmp = str.substr(pos_begin);
            pos_begin = comma_pos;
        }

        if (!tmp.empty())
        {
            ret_.push_back(tmp);
            tmp.clear();
        }
    }
    return ;
}

bool CheckAllBeenSet(vector<pair<string, int> > itemsToCheck)
{
    vector<pair<string, int> >::iterator it = itemsToCheck.begin();
    while (it != itemsToCheck.end())
    {
        if (it->second == INVALID_VALUE)
        {
            return false;
        }

        it++;
    }
    return true;
}

void PrintItems(vector<pair<string, int> > itemsToCheck)
{
    vector<pair<string, int> >::iterator it = itemsToCheck.begin();
    while (it != itemsToCheck.end())
    {
        cout << "KEY = " << it->first << " , VALUE = " << it->second << " KB "<< endl;
        it++;
    }
}

unsigned int CheckFreeMemInKByte(vector<pair<string, int> > itemsToCheck)
{
    // 空闲内存计算方式：如果Cached值大于MemTotal值则空闲内存为MemFree值，否则空闲内存为MemFree值+Buffers值+Cached值
    int rlt;
    if (itemsToCheck[CACHED].second > itemsToCheck[MEMTOTAL].second)
    {
        rlt = itemsToCheck[MEMFREE].second;
        if (isDebugging)
        {
            cout << "CACHED(" << itemsToCheck[CACHED].second << "KB) > MEMTOTAL(" << itemsToCheck[MEMTOTAL].second << "KB)\n";
            cout << "FreeMemInKb is " << rlt << "KB\n";
        }
    }
    else
    {
        rlt = itemsToCheck[CACHED].second + itemsToCheck[MEMFREE].second + itemsToCheck[BUFFERS].second;
        if (isDebugging)
        {
            cout << "CACHED(" << itemsToCheck[CACHED].second << "KB) <= MEMTOTAL(" << itemsToCheck[MEMTOTAL].second << "KB)\n";
            cout << "FreeMemInKb is " << rlt << "KB\n";
        }
    }

    return rlt;
}

// usage
int main(int argc, char *agrv[])
{
    if (argc <  || argc > )
    {
        cout << "Usage :\n memCons fromTotalMem freePercentage [isDebugging]\n";
        cout << "For example : \'memCons 0 1\'\n means to take 99% of freeMem, that is to leave only 1% out of free memory\n";
        cout << "For example : \'memCons 1 1\'\n means to take 99% of totalMem, that is to leave only 1% out of all the memory\n";
        cout << "For example : \'memCons 1 1 1\'\n means in the debugging mode\n";
        return -;
    }
    bool fromTotalMem = atoi(agrv[]) ==  ? true : false;
    int freePercentage = atoi(agrv[]);
    isDebugging = (argc ==  && atoi(agrv[]) == ) ? true : false;

    if (!(freePercentage >  && freePercentage < ))
    {
        cout << "the second argument of memCons must between 0 and 100";
        return -;
    }

    struct sysinfo s_info;
    int error;

    error = sysinfo(&s_info);
    printf("the followings are output from \'sysinfo\' call \n\ncode error=%d\n",error);
    printf("Uptime = %ds\nLoad: 1 min%d / 5 min %d / 15 min %d\n"
          "RAM: total %d / free %d /shared%d\n"
          "Memory in buffers = %d\nSwap:total%d/free%d\n"
          "Number of processes = %d\n\n\n",
          s_info.uptime, s_info.loads[],
          s_info.loads[], s_info.loads[],
          s_info.totalram, s_info.freeram,
          s_info.totalswap, s_info.freeswap,
          s_info.procs );

    vector< pair<string, int> > itemsToCheck;
    std::pair <std::string, int> memTotal(ItemCheckName[MEMTOTAL], INVALID_VALUE);
    itemsToCheck.push_back(memTotal);
    std::pair <std::string, int> memfreePair(ItemCheckName[MEMFREE], INVALID_VALUE);
    itemsToCheck.push_back(memfreePair);
    std::pair <std::string, int> buffers(ItemCheckName[BUFFERS], INVALID_VALUE);
    itemsToCheck.push_back(buffers);
    std::pair <std::string, int> cached(ItemCheckName[CACHED], INVALID_VALUE);
    itemsToCheck.push_back(cached);

    vector<string> splitedWords;

    ifstream infile(MEM_INFO_FILE_NAME);
    if (infile.fail())
    {
        cerr << "error in open the file";
        return false;
    }

    int hitCnt = itemsToCheck.size();
    while(hitCnt != )
    {
        splitedWords.clear();
        char temp[];
        infile.getline(temp, ); 

        const string tmpString = temp;

         split(tmpString, splitedWords, ":"); 

        // use the first part to check whether to continue
         splitedWords[] = trim(splitedWords[]);
        int foundIndex = -;
        for (int i = ; i < itemsToCheck.size(); i++)
        {
            if (itemsToCheck[i].first == splitedWords[])
            {
                foundIndex = i;
                hitCnt--;
                break;
            }
        }

        if (foundIndex  == -)
        {
            continue;
        }

        // check the number
        string numberInString = trim(splitedWords[]);
        int firstNotNumberPos = numberInString.find_first_not_of("");
        numberInString.substr(, firstNotNumberPos);
        int num = atoi(numberInString.c_str());

        // insert into container
        itemsToCheck[foundIndex].second = num;

        if (infile.eof())
        {
            break;
        }
    }
    infile.close();

    PrintItems(itemsToCheck);

    if (CheckAllBeenSet(itemsToCheck) == false)
    {
        cout << "Error in checking " << MEM_INFO_FILE_NAME << endl;
        return -;
    }

    // set used memory according to the requirements
    long long memToUse = ;
    long long freeMemCount = ;

    if (isDebugging)
    {
        cout << "Need memory use in total one ? " << fromTotalMem << endl;
    }
    if (!fromTotalMem)
    {
        if (isDebugging)
        {
            cout << "Need memory use in free one\n";
        }
        freeMemCount = CheckFreeMemInKByte(itemsToCheck);
    }
    else
    {
        if (isDebugging)
        {
            cout << "Need memory use in total one\n";

            cout << "total memory is " << itemsToCheck[MEMTOTAL].second << "KB, that " << itemsToCheck[MEMTOTAL].second *  << "B" << endl;
        }

        freeMemCount = itemsToCheck[MEMTOTAL].second;
    }

    cout << "Free Mem Count is " << freeMemCount << "KB" << endl;
    memToUse = freeMemCount * ((double) - (double)((double)freePercentage / (double)) );
    cout << "MemToUse  is " << memToUse << "KB" << endl;

    char* memConsumer[];
    int j = ;
    for (; j < ; j++)
    {
        memConsumer[j] = NULL;
    }
    try
    {
        for (j = ; j < ; j++)
        {
            if (memConsumer[j] == NULL)
            {
                memConsumer[j] = new char[memToUse];
            }
            for (int i = ; i < memToUse; i++)
            {
                memConsumer[j][i] = '';
            }
        }
    }
    catch(std::bad_alloc)
    {
        // swallow the exception and continue
        cout << "no more memory can be allocated, already alloced " << j * memToUse << "B";
    }
    while ()
    {
        sleep();
    }

    return ;
}