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

#define MAX_LINE 256    /* 最大行 */
#define MAX_LEN_OF_LINE 256 /* 行の最大文字列長 */

/* qsort()で使う */
int cmp(const void *s1, const void *s2)
{
  return strcmp(*(const char **)s1, *(const char **)s2);
}

/* 複製した文字列の先頭を指すポインタを返す関数 */
char *strdup(const char *s)
{
  char *p;

  p = malloc(strlen(s) + 1);    /* 文字列終端子の分、一つ多く領域確保 */
  if (p != NULL)    /* メモリ確保に成功した場合 */
    strcpy(p, s);   /* 文字列をコピーする */

  return p;
}

int main(void)
{
  char *str[MAX_LINE];
  char strtemp[MAX_LEN_OF_LINE];  /* 文字列を一時的に記憶するための配列 */
  int i, j;
 
  for (i = 0; fgets(strtemp, MAX_LEN_OF_LINE, stdin); i++) {  /* 標準入力から strtemp に一行読み込み、ファイルの終わりまでかエラーが発生した場合はループを終了させる */
    str[i] = strdup(strtemp);    /* str[i]に strtemp を複製 */
    str[i][strlen(str[i]) - 1] = '\0';    /* 文字列の最後にある'\n'を'\0'に置換 */
  }

  qsort((void *)str, i, sizeof(char *), cmp);  /* 文字列のソート */

  for (j = 0; j < i; j++) {  /* 入力された行の数だけ繰り返す */
    puts(str[j]);  /* 今までstrに格納し、ソートされたものを標準出力 */
    free(str[j]);  /* strdup()で確保した文字列の領域の解放 */
  }

  return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

int main()
{
    using namespace std;
    vector<string> lines;
    string buf;
    while (getline(cin, buf)) lines.push_back(buf);
    sort(lines.begin(), lines.end());
    copy(lines.begin(), lines.end(), ostream_iterator<string>(cout, "\n"));
}

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

typedef struct { char **data; size_t size, capacity; } Vec;
typedef struct { char  *data; size_t size, capacity; } Buf;

void error(void) { fputs("out of memory\n", stderr); exit(1); }

Vec *vec_init(void)
{
    Vec *p = malloc(sizeof(Vec));
    if (p == NULL) error();
    p->size = 0;
    p->capacity = 256;
    p->data = malloc(p->capacity * sizeof(char *));
    if (p->data == NULL) error();
    return p;
}

Buf *buf_init(void)
{
    Buf *p = malloc(sizeof(Buf));
    if (p == NULL) error();
    p->size = 0;
    p->capacity = 256;
    p->data = malloc(p->capacity);
    if (p->data == NULL) error();
    return p;
}

void vec_add(Vec *vp, const char *s)
{
    if (vp->size == vp->capacity) {
        vp->capacity *= 2;
        vp->data = realloc(vp->data, vp->capacity);
        if (vp->data == NULL) error();
    }
    vp->data[vp->size] = strdup(s);
    if (vp->data[vp->size++] == NULL) error();
}

void buf_add(Buf *bp, int c)
{
    if (bp->size == bp->capacity) {
        bp->capacity *= 2;
        bp->data = realloc(bp->data, bp->capacity);
        if (bp->data == NULL) error();
    }
    bp->data[bp->size++] = c;
}

int getline(FILE *fp, Buf *bp)
{
    int c;
    bp->size = 0;
    while ((c = getc(fp)) != EOF && c != '\n') buf_add(bp, c);
    buf_add(bp, 0);
    return bp->size > 1 || c != EOF;
}

int comp(const void *a, const void *b)
{
    return strcmp(*(char **)a, *(char **)b);
}

int main(void)
{
    Vec *lines = vec_init();
    Buf *buf = buf_init();
    size_t i;

    while (getline(stdin, buf)) vec_add(lines, buf->data);
    qsort(lines->data, lines->size, sizeof(char *), comp);
    for (i = 0; i < lines->size; i++) puts(lines->data[i]);
    /* vec_free(vec); */
    /* buf_free(buf); */
    return 0;
}

>   vp->data = realloc(vp->data, vp->capacity);

    vp->data = realloc(vp->data, vp->capacity * sizeof(char *));

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

typedef struct { char **data; size_t size, capacity; } Vec;
typedef struct { char  *data; size_t size, capacity; } Buf;

void error(void) { fputs("out of memory\n", stderr); exit(1); }

void vec_add(Vec *vp, const char *s)
{
    if (vp->size == vp->capacity) {
        vp->capacity = vp->capacity ? vp->capacity * 2 : 256;
        vp->data = realloc(vp->data, vp->capacity * sizeof(char *));
        if (vp->data == NULL) error();
    }
    vp->data[vp->size] = strdup(s);
    if (vp->data[vp->size++] == NULL) error();
}

void buf_add(Buf *bp, int c)
{
    if (bp->size == bp->capacity) {
        bp->capacity = bp->capacity ? bp->capacity * 2 : 256;
        bp->data = realloc(bp->data, bp->capacity);
        if (bp->data == NULL) error();
    }
    bp->data[bp->size++] = c;
}

int getline(FILE *fp, Buf *bp)
{
    int c;
    bp->size = 0;
    while ((c = getc(fp)) != EOF && c != '\n') buf_add(bp, c);
    buf_add(bp, 0);
    return bp->size > 1 || c != EOF;
}

int comp(const void *a, const void *b)
{
    return strcmp(*(char **)a, *(char **)b);
}

int main(void)
{
    Vec lines = { 0 };  Buf buf = { 0 };  size_t i;

    while (getline(stdin, &buf)) vec_add(&lines, buf.data);
    qsort(lines.data, lines.size, sizeof(char *), comp);
    for (i = 0; i < lines.size; i++) puts(lines.data[i]);
    /* vec_free(&lines); */
    /* buf_free(&buf); */
    return 0;
}

#include <cstdlib>
#include <vector>
#include <ctime>
#include <iostream>
#include <algorithm>

const int N = 3000000;
int cmp(const void *, const void *);

struct Test {
  double d;
//  double dummy[1];
};

struct Test2 {
  int d;
//  double dummy[1];
};

typedef Test TYPE; // Choose structure type which shall be tested.

class cmp2 {
public:
  bool operator()(const TYPE& a, const TYPE& b) {
    if (a.d >= b.d) return true;
    else return false;
  }
};

int main()
{
  static TYPE d[N];
  std::vector<TYPE> vd;
  std::clock_t ti;
  
  std::srand(0);
  for (int i = 0; i < N; i++) d[i].d = std::rand() * RAND_MAX + std::rand();
  std::srand(0);
  for (int i = 0; i < N; i++) {
   TYPE t;
   t.d = std::rand() * RAND_MAX + std::rand();
   vd.push_back(t);
  }
  
  ti = std::clock();
  std::qsort(d, N, sizeof(TYPE), cmp);
  std::cout << "qsort = " << (std::clock() - ti) << std::endl;

  ti = std::clock();
  std::sort(vd.begin(), vd.end(), cmp2());
  std::cout << "sort = " << (std::clock() - ti) << std::endl;
}

int cmp(const void* a, const void* b)
{
  if (static_cast<const TYPE*>(a)->d > static_cast<const TYPE*>(b)->d) return -1;
  else if (static_cast<const TYPE*>(a)->d < static_cast<const TYPE*>(b)->d) return 1;
  return 0;
}