C에서 리터럴 문자열 주소는 항상 할당 된 문자열 주소보다 커야합니까?

Question

실수로 segfault를 일으키는 리터럴 문자열을 시도하지 않도록 할당 된 문자열과 리터럴 문자열을 구별하려고합니다.

내가 리터럴 문자열 thusly 히 내장 할 수있는 strcat와() 래퍼 포함) (무료로 시도 할 수 있습니다 이유 : 이유에 관계없이 strcatex("My name ", strcatex("is ", strMyName));

을 고려 :

void* mallocex(int intBytes) 
{ 
    void* newPtr; 

    newPtr = malloc(intBytes); 

    if(newPtr == 0) 
     return 0; 
    else if(newPtr > maxPointer) 
     maxPointer = newPtr; 

    return newPtr; 
} 

및

을

int SafeFree(void **ptr) 
{ 
    if((unsigned long) ptr > (unsigned long) maxPointer) 
     return 0; 
    else 
     free(*ptr); 

    return 1; 
} 

사용 예제 :

char *newString; 
newString = (char*) mallocex(12); 

strcpy(newString, "Example one"); 

SafeFree(&newString); 
SafeFree("Example two"); 

힙 크기에 관계없이 항상 작동합니까?

Answer 1

보증에 의거하지 마십시오.
문자열 리터럴은 읽기 전용 구현 정의 영역의 어딘가에 메모리가 할당되어 있습니다.이 영역은 이동식으로 무엇이 될지를 알 수 없으므로 이에 대해 어떠한 가정도해서는 안됩니다.

Answer 2

상황은 상상하는 것보다 "악화"됩니다. 비교는 동일한 객체를 가리키는 포인터 (또는 그 이상의 바이트)를 가리키는 포인터에 대해서만 정의됩니다. 일반적으로 문자열 리터럴로 또는 동적으로 malloc 또는 그 이상으로 할당 된 두 개의 다른 객체에 대해서는 다른 하나보다 작은 주소가 있는지 여부를 묻지도 못합니다. 대부분의 플랫폼에서 이와 같은 비교가 가능하지만 엄밀한 의미에서 의존 할 수는 없습니다.

Answer 3

보증이없는 것뿐만 아니라 정반대 인 시스템은 매우 일반적입니다. 예를 들어 맥 OS (내 컴퓨터)에 :

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

void pr_addr(const char *name, void *addr) { 
    printf("%s: %p\n", name, addr); 
} 

int main(void) { 
    pr_addr("literal", "literal"); 
    pr_addr("heap", malloc(10)); 
    return 0; 
} 
$ cc -o foo -W -Wall -O foo.c 
$ ./foo 
literal: 0x1ff1 
heap: 0x100160 

그래서 여기 rodata 섹션은 malloc 경기장 잘 아래의 시작, 당신이 당신의 시스템에 표시되는 내용의 반대입니다.

일반적으로 조각 세분화 또는 기타 구조화 된 포인터 유형이있는 시스템은 인접하지 않은 개체 간의 의미없는 비교로 마무리됩니다. p < q에 대한 테스트는 종종 세그먼트 내 오프셋의 비교로 컴파일됩니다. 예를 들어, p 및 q이 모두 (다른) 세그먼트의 시작을 가리키는 경우 주소가 다르더라도 오프셋 모두가 0입니다. 따라서 p < q과 p > q은 모두 거짓이며 아직 p != q입니다.

Answer 4

재미 있기 때문에 다른 리터럴의 주소를 기반으로 추측하려고 시도했습니다. 잠재적 리터럴의 주소를 다른 알려진 리터럴, 스택 주소 및 힙 주소와 비교하여 작동합니다. 잠재적 주소가 다른 주소보다 리터럴에 더 가깝다면 잠재적 주소가 리터럴이라고 가정합니다. 아마도 실제로는 신뢰할 수 없습니다. 다음은 단순한 버전입니다.

int is_literal_simplistic(char *s) { 
    char *literal = "literal"; 
    char stack[] = "stack"; 
    char *heap = malloc(1); 
    free(heap); 
    unsigned long literal_delta = labs(literal - s); 
    unsigned long stack_delta = labs(stack - s); 
    unsigned long heap_delta = labs(heap - s); 
    return (literal_delta < stack_delta && literal_delta < heap_delta); 
} 

여기에는 좀 더 간결한 버전이 나와 있습니다.아마 수 있습니다 간단 :

int is_literal(char *s) { 
    char *heap = malloc(1); 
    free(heap); 
    unsigned long literal_delta = labs("literal" - s); 
    unsigned long stack_delta = labs((char *)&s - s); 
    unsigned long heap_delta = labs(heap - s); 
    return (literal_delta < stack_delta && literal_delta < heap_delta); 
} 

전체 실행 가능한 테스트 : 비교하기 전에 서명되지 않은 long``에 캐스팅하여`SafeFree() '함수의 전체 휴대 성을 개선하기위한

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

//#define DEBUG 

#ifdef DEBUG 
void debug_literal(unsigned long literal, 
        unsigned long stack, 
        unsigned long heap, 
        unsigned long literal_delta, 
        unsigned long stack_delta, 
        unsigned long heap_delta) { 
    printf("literal(%lx) stack(%lx) heap(%lx)\n", literal, stack, heap); 
    printf("literal(%lu) stack(%lu) heap(%lu)\n", literal_delta, stack_delta, heap_delta); 
    int answer = (literal_delta < stack_delta && literal_delta < heap_delta); 
    printf("\t%s\n", answer ? "literal" : "other"); 
} 
#else 
void debug_literal(unsigned long literal, 
        unsigned long stack, 
        unsigned long heap, 
        unsigned long literal_delta, 
        unsigned long stack_delta, 
        unsigned long heap_delta) { 
} 
#endif 

int is_literal_simplistic(char *s) { 
    char *literal = "literal"; 
    char stack[] = "stack"; 
    char *heap = malloc(1); 
    free(heap); 
    unsigned long literal_delta = labs(literal - s); 
    unsigned long stack_delta = labs(stack - s); 
    unsigned long heap_delta = labs(heap - s); 
    debug_literal((unsigned long)literal, (unsigned long)stack, (unsigned long)heap, 
        literal_delta, stack_delta, heap_delta); 
    return (literal_delta < stack_delta && literal_delta < heap_delta); 
} 

int is_literal(char *s) { 
    char *heap = malloc(1); 
    free(heap); 
    unsigned long literal_delta = labs("literal" - s); 
    unsigned long stack_delta = labs((char *)&s - s); 
    unsigned long heap_delta = labs(heap - s); 
    debug_literal(0,0,0, literal_delta, stack_delta, heap_delta); 
    return (literal_delta < stack_delta && literal_delta < heap_delta); 
} 

void test_literal_function(int(*liternal_fn)(char *)) { 
    char *literal = "literal_test"; 
    char stack[] = "stack_test"; 
    char *heap = malloc(40); 

    printf("\t%s\n", liternal_fn(literal) ? "literal" : "other"); 
    printf("\t%s\n", liternal_fn(stack) ? "literal" : "other"); 
    printf("\t%s\n", liternal_fn(heap) ? "literal" : "other"); 
    printf("\n"); 

    free(heap); 
} 

int main() { 
    test_literal_function(is_literal_simplistic); 
    test_literal_function(is_literal); 

    return 0; 
}