c - 如何为您的程序设置内存上限

Question

如何在我的 C(或者，原则上但在本例中不是 C++)程序中设置 RAM、堆或堆栈使用的上限？我在 Windows 10 上使用 Visual Studio。

我有一个完整的程序(嗯，库和一个小程序来运行基本测试并将其演示给我正在辅导的人)，我想展示内存分配失败时会发生什么。 (而且我不只是用一个愚蠢的大分配来做这件事，因为它是链表，我想在那种情况下显示内存分配失败。)所以:我怎样才能限制我的程序允许使用的内存量，我会在哪里做呢？我会在操作系统中做些什么来告诉它“我要运行的这个应用程序只能使用 X 字节的 RAM”(或者甚至可能告诉它限制堆或堆栈大小)，我会在编译器参数，链接器参数，还是什么？

而且我编写的代码具有防止非法内存访问以及随后在 malloc(或仅在少数地方，calloc)返回 NULL 时崩溃的代码!所以不要担心非法内存访问和其他东西，我对我在做什么有一个相当好的想法。

这是库标题，singleLinkList.h ， 好像:

#ifndef SINGLELINKEDLIST_H
#define SINGLELINKEDLIST_H

#ifndef KIND_OF_DATA
#define KIND_OF_DATA 3
#endif // !KIND_OF_DATA





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

typedef long long LL_t;


#if KIND_OF_DATA == 1

typedef float data_t;
#define DATA_FORM "%f"

#elif KIND_OF_DATA == 2

typedef double data_t;
#define DATA_FORM "%lf"

#elif KIND_OF_DATA == 3

typedef LL_t data_t;
#define DATA_FORM "%lld"

#else

typedef int data_t;
#define DATA_FORM "%d"

#endif // KIND_OF_DATA == 1, 2, etc...


struct listStruct;


// equivalent to `list_t*` within the .c file
typedef struct listStruct* LS_p;

// equivalent to `const list_t* const` within the .c file
typedef const struct listStruct* const LS_cpc;

typedef struct listStruct* const LS_pc;



int showSizes(void);
size_t queryNodeSize(void);

// returns NULL on failure
LS_p newList(void);

// returns NULL on failure (in memory alloc, at any point), or if given the NULL pointer
LS_p mkListCopy(LS_cpc);

// copies one list into another; leaves the destination unmodified upon failure
//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// -1 indicates that you gave the NULL pointer
int copyList(LS_pc dst, LS_cpc src);


//destroys (frees) the given singly-linked list (the list_t* given, and all the list of nodes whose head it holds)
void destroyList(LS_p);

// destroys the list pointed to, then sets it to NULL
//inline void strongDestroyList(LS_p* listP) {
inline void strongDestroyList(struct listStruct** listP) {
    destroyList(*listP);
    *listP = NULL;
}

// Takes a pointer to a list_t
// returns how many elements it has (runs in O(n) time)
//  If you don't understand what `O(n) time` means, go look up "Big O Notation"
size_t len_list(LS_cpc);


//prints a list; returns characters printed
int print_list(LS_cpc);


// gets the data at the specified index of the list; sets the output parameter on failure
data_t indexToData(LS_pc, const size_t ind, int* const err);

// will write the data at ind to the output parameter
//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// -1 indicates that you gave the NULL pointer
int copyToPointer(LS_pc, const size_t ind, data_t* const out);


// gets the data at the specified index and removes it from the list; sets output param on failure
data_t popFromInd(LS_pc, const size_t ind, int* const errFlag);

// pops the first item of the list; sets the output param on failure
data_t popFromTop(LS_pc, int* const errFlag);

//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// -1 indicates that you gave the NULL pointer
int assignToIndex(LS_pc, const size_t ind, const data_t value);



//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// 2 indicates inability to reach the specified index, because it's not that long.
// -1 indicates that you gave the NULL pointer
int insertAfterInd(LS_pc, const size_t ind, const data_t value);


//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// -1 indicates that you gave the NULL pointer
int appendToEnd(LS_pc, const data_t value);


//returns a value indicating success/type of failure; returns 0 on success, 
//  various `true` values on failure depending on type
// 1 indicates simple allocation failure
// -1 indicates that you gave the NULL pointer
int insertAtStart(LS_pc list, const data_t value);


#endif // !SINGLELINKEDLIST_H

这就是 main.c ，它运行演示/测试，看起来像:

#ifdef __INTEL_COMPILER
#pragma warning disable 1786
#else
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS 1
#endif // _MSC_VER

#endif // __INTEL_COMPILER


#include "singleLinkList.h"

#include <stdio.h>
#include <string.h>



void cleanInputBuffer(void) {
    char c;
    do {
        scanf("%c", &c);
    } while (c != '\n');
}


void fill_avail_memory(void) {
    size_t count = 0;
    LS_p list = NULL;
    size_t length;
    data_t fin;
    int err = 0;
    const size_t nSize = queryNodeSize();
    printf("nSize: %zu\n", nSize);
    int last = -5;
    printf("Do you wish to run the test that involves filling up available memory? "
        "(only 'y' will be interpreted as an affirmative) => ");
    char ans;
    scanf("%c", &ans);
    cleanInputBuffer();
    if ((ans != 'y') && (ans != 'Y')) {
        printf("Okay. Terminating function...\n");
        return;
    }
    printf("Alright! Proceeding...\n");
    list = newList();
    if (list == NULL) {
        printf("Wow, memory allocation failure already. Terminating...\n");
        return;
    }
    print_list(list);
    while (!(last = insertAtStart(list, (data_t)count))) {
        ++count;
    }
    length = len_list(list);
    if (length < 5) {
        print_list(list);
    }
    fin = indexToData(list, 0, &err);
    strongDestroyList(&list);
    printf("Last return value: %d\n", last);
    if (!err) {
        printf("Last inserted value: " DATA_FORM "\n", fin);
    }
    printf("Count, which was incremented on each successfull insert, reached: %zu\n", count);
    printf("Length, which was calculated using len_list, was: %zu\n", length);
}



int main() {
    printf("Hello world!\n");
    showSizes();
    LS_p list = newList();
    print_list(list);

    printf("Printing the list: "); print_list(list);
    printf("Appending 5, inserting 1987 after it...\n");
    appendToEnd(list, 5);
    insertAfterInd(list, 0, 1987);
    printf("Printing the list: "); print_list(list);
    printf("Inserting 15 after index 0...\n");
    insertAfterInd(list, 0, 15);
    printf("Printing the list: "); print_list(list);
    printf("Appending 45 to the list\n");
    appendToEnd(list, 45);
    printf("Printing the list: "); print_list(list);
    //destroyList(list);
    //list = NULL;
    printf("Value of pointer-variable `list` is 0x%p\n", list);
    printf("Destroying list...\n");
    strongDestroyList(&list);
    printf("Value of pointer-variable `list` is 0x%p\n", list);

    printf("\n\n\n");
    fill_avail_memory();

    return 0;
}

(__INTEL_COMPILER 和 _MSC_VER 的内容是为了压制关于使用 scanf 的废话。

所以:

是否可以设置内存使用上限？

如果是这样，它可以是堆与堆栈特定的吗？

如果没有，有没有办法让它只使用物理内存？

如果可以设置内存上限，我应该在哪里设置(在操作系统、编译器选项、链接器选项，甚至其他地方)，我该怎么做？

我将从终端编译(而不仅仅是“运行代码”，因为它是一个 Visual Studio 项目)如下:

cl singleLinkList.c -c
cl main.c /Zp4 /link singleLinkList.obj

任何帮助，或在哪里看的建议，将不胜感激!谢谢!
更新:人们建议了工作对象。这看起来是一个 C++ 的东西。它会在纯C中工作吗？ (如果不是，那么虽然可能就足够了，但这并不是我想要/希望的。)

Answer 1

如果您想在用户/运行时级别执行此操作(并控制正在测试的代码)，您可以实现自己的 safe_malloc() , safe_calloc() , safe_realloc() , 和 safe_free()这将充当系统提供的对应物的前端，并会增加或减少 numberOfBytesUsed适本地反击，但如果 numberOfBytesUsed 会失败将变得大于固定的最大值。

(请注意，由于 free() 不包含免费字节数参数，因此这样做有点棘手，因此您必须在分配的缓冲区中“隐藏”该信息返回safe_calloc() 和 friend 们——通常通过在调用代码请求的内容之上分配额外的 4 个字节，将分配大小值放在分配的前 4 个字节中，然后在分配大小之后返回指向第一个字节的指针 field )

如果您无法控制正在测试的代码(即该代码将直接调用 malloc() 和 free() 并且您不能重写代码来调用您的函数，那么您可能会做一些讨厌的事情一些预处理器的魔法(例如 #define calloc safe_calloc 在你知道将被包含的头文件中)来欺骗被测试的代码做正确的事情。

至于限制使用的堆栈空间量，我不知道有任何优雅的方法可以在代码级别强制执行。如果有办法使用编译器标志来强制执行它，您至少可以让程序在堆栈溢出条件下可靠地崩溃，但这与受控/处理的故障并不完全相同。