인쇄 마지막으로-n 라인의 입력

Question

#include <stdio.h>

#define MAXLINES    5000    /* Maximum number of lines to display. */

char *lineptr[MAXLINES];    /* Pointer to input lines. */

#define BUFFERSIZE 1000

#define DEFAULT_LAST 10

int readlines(char *lineptr[], char *buffer, int maxlines);
static void unwrap(char *buffer, int index);
static void reverse(char *lineptr[], int nlines);

main(int argc, char *argv[])
{
    int nlines, i, last, offset;
    char buffer[BUFFERSIZE];
    char *p;

    last = DEFAULT_LAST;
    for (i = 0; i < argc; i++) {
        p = argv[i];
        if (*p++ == '-') {
            last = 0;
            while (isdigit(*p)) {
                last = last * 10 + *p - '0';
                p++;
            }
            if (*p != '\0') {
                printf("invalid argument: %s\n", argv[i]);
                last = DEFAULT_LAST;
            }
        }
    }

    nlines = readlines(lineptr, buffer, MAXLINES);
    if (nlines < 0) {
        printf("error: input too big to process\n");
        return 1;
    }
    if (nlines < last) {
        printf("error: only printing the last %d lines.\n", nlines);
        offset = 0;
    } else if (last > MAXLINES) {
        offset = nlines - MAXLINES;
    } else {
        offset = nlines - last;
    }
    for (i = 0; i < nlines && i < last; i++)
        printf("%s\n", lineptr[offset + i]);

    return 0;
}

int readlines(char *lineptr[], char *buffer, int maxlines)
{
    int c, nlines;
    int wrapped;
    char *p;

    /* The input lines are stored end-to-end in the buffer, with
       newlines converted to null bytes. */
    wrapped = 0;
    p = buffer;
    while ((c = getchar()) != EOF) {
        if (c == '\n')
            *p = '\0';
        else
            *p = c;
        p++;
        if (p >= buffer + BUFFERSIZE) {
            p = buffer;
            wrapped = 1;
        }
    }
    /* Rearrange the buffer so the oldest byte comes first. */
    if (wrapped) {
        unwrap(buffer, p - buffer);
        p = buffer + BUFFERSIZE;
    }
    p--;
    *p = '\0';
    nlines = 0;
    while (p >= buffer && nlines < maxlines) {
        p--;
        if (*p == '\0')
            lineptr[nlines++] = p + 1;
    }
    reverse(lineptr, nlines);

    return nlines;
}

static void unwrap(char *buffer, int index)
{
    char work[BUFFERSIZE];

    memmove(work, buffer + index, BUFFERSIZE - index);
    memmove(work + BUFFERSIZE - index, buffer, index);
    memmove(buffer, work, BUFFERSIZE);

    return;
}

static void reverse(char *lineptr[], int nlines)
{
    char *tmp;
    int i;

    for (i = 0; i < nlines / 2; i++) {
        tmp = lineptr[i];
        lineptr[i] = lineptr[nlines - i - 1];
        lineptr[nlines - i - 1] = tmp;
    }
return;
}

이 프로그램 인쇄 마지막으로-n 라인의 입력,저장하는 라인으로 포인터 배열.

에 readlines 함수의 경우 포인터 버퍼 십자가의 최대 크기는 그것을 얻는 마법.하지만 내가 무슨 말인지 이해할 수 없는 wraping/unwraping 기능 하십니다.할 수 있는 누군가가 그것을 설명을까?방법 포장 및 작동유주의 작가이드-1 을 반환하는 경우 버퍼를 넘쳐?

Answer 1

을 보여 원리:말을 두고 있 10 자'0''9',로 8 바이트 버퍼를 사용하여,같은 방식:

후 7 자:

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 |   |
+---+---+---+---+---+---+---+---+
  ^                           ^
buffer                        p

후 8 특성:

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
  ^                               ^
buffer                            p

그래서 지금 p 를 재설정하고 wrapped 1 로 설정:

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
  ^
buffer
  p

후에 10 번째 문자:

+---+---+---+---+---+---+---+---+
| 8 | 9 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
  ^       ^
buffer    p

지금 unwrap() 코드를 다시 정렬 버퍼처럼 보이:

+---+---+---+---+---+---+---+---+
| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+---+---+---+---+---+---+---+---+
  ^                               ^
buffer                            p

프로그램 하고 있는 이(오히려 그냥 포기)그래서 그것은 여전히 작동할 것입니다 경우에도 파일보다 훨씬 더 큰 버퍼입니다.(지 않는 한의 총 길이는 마지막 10 개의 선보다 더 큰 버퍼 는 경우 앞의 일부의 지난 10 인 손실됩니다).

Answer 2

이 프로그램은 모든 줄을 라인 배열로 읽습니다. 배열의 각 요소는 고정 된 크기입니다. 라인이 라인의 최대 크기보다 길면 "랩"하고 버퍼 시작시 버퍼를 채우는 것을 다시 시작합니다.

그런 다음 풀림은 끝에 가장 오래된 물건을 넣어 줄의 시작 부분에서 줄이 잘린 것처럼 보입니다. (10 문자 버퍼의 12 자 라인은 세 번째 문자에서 시작하는 마지막 10자를 보여줍니다.)