… read_lines(FILE* fp, char** *rszLines, size_t *pcLines);

errno_t read_lines(FILE* fp, char** *rszLines, size_t *pcLines);

/**
 * Читает файл и возвращает массив его строк.
 * @param [in, out] fp Открытый файл. Не закрывается.
 * @param [out] prszLines На выходе указывает на массив указателей на строки файла.
 *                        Клиент должен освободить каждую строку и сам массив функцией free().
 * @param [out] pcLines На выходе содержит количество строк в массиве.
 * @returns код ошибки.
 */
errno_t read_lines(FILE* fp, char** *prszLines, size_t *pcLines);

char** rszLines;
size_t cLines;
switch (read_lines(fp, &rszLines, &cLines))
{
…
}

int get_lines_as_strings(FILE *, char **ptr);

...

char *strings; // указатель на первый (нулевой) элемент массива строк.
int numlines = get_lines_as_strings(f, &strings);

int get_lines_as_strings(FILE *, char **ptr);

Потому что очень много низкокачественных C++ программистов (перешедших с C), которые
верят в то, что C быстрее чем C++,
верят в void* и т.п.,
думают что C++ это раздутые OO-иерархии,
могли обжечься 20 лет назад об C++ и этот опыт имеет их до сих пор.
В результате, когда этот сброд слышит embedded, fast, system, kernel — они бездумно используют C.

На сегодняшний день я вижу только следующие места когда можно обоснованно использовать C, а не C++ :
1) Отсутствие компилятора C++
2) В API (причём это не сам C, а только C-style interfaces)
3) В распоряжении есть только программисты знающие C, но не C++
4) Необходимость ковыряться в уже написанном на C проекте

P>>у тебя макросы запрятаны в yoyo lib, что мешает запрятать обвёртки C++ в либу, или даже использовать готовые?

AS>std::unique_ptr<MyySuperType> a(new MySuperType);
AS>

P>>В C++ никто не заставляет тебя использовать non-intrusive'ные traits.

#define while(x) /*BOOM Baby!*/

int get_lines_as_strings(FILE *, char **ptr); // возвращает количество строк и устанавливает указатель на массив указателей на строки.

int get_lines_as_strings(FILE *, char **ptr);

...

char **strings;
int numlines = get_lines_as_strings(f, strings);

int main()
{
        int a;
        void *p=&a;
        int *b=static_cast<int*>(p);
        return 0;
}

struct string_list
{
};

int string_list_create(struct string_list * restrict result, FILE * f);
void string_list_destroy(struct string_list * restrict this);
const char * string_list_next(struct string_list * restrict this);
...

I>int get_lines_as_strings(FILE *, char const *const **); // возвращает количество строк
I>

I>struct strings {
I>    int num; // количество строк
I>    char const *const *str;
I>};

I>void get_lines_as_strings(FILE *, struct strings *);
I>

I>struct strings {
I>    int num; // количество строк
I>    char const *const *str;
I>};

I>struct string get_lines_as_strings(FILE *);
I>

void get_lines_as_strings(FILE *,char***);
char** get_lines_as_strings(FILE *);
strings* get_lines_as_strings(FILE *);

void get_lines_as_strings(FILE *,char**, Allocator* al, int maxLength);

char** get_lines_as_strings(FILE *)
{
//вызываем общий менеджер, управляющий память 
GodStruct* god = callMeGod();
char** result  = (char**)godAlloc();
...
result[i] = godPush(stringRead);
...
}

char** get_lines_as_strings(FILE *, GodStruct*)
{
}

backupState(god);
char** result = get_lines_as_strings(FILE * file, GodStruct* god, int* errorCode);
if(result == NULL)
{
  if(errorCode == FILE_READ_ERROR)
    reportFileNotRead(..);
  else if(errorCode == MEMORY_ALLOC_ERROR)
  {
    rollbackState(god);
    reportMemoryAllocError(god);
  }
}

struct context * restrict ctx = allocate_context;
int error_code = setjmp(ctx->jmp_on_error);
if (error_code == 0)
  perform_context_caclulation(ctx);

if (error_code)
{
  printf("Was error %d\n", error_code);
  // Мы можем хранить расширенную информацию в самом контексте
  // printf("Message %s\n", ctx->error_msg);
}

free_context(ctx);

SN>int get_lines_as_strings(FILE *, char **ptr); // возвращает количество строк и устанавливает указатель на массив указателей на строки.

SN>int get_lines_as_strings(FILE *, char **ptr);

SN>...

SN>char **strings;
SN>int numlines = get_lines_as_strings(f, strings);

YO_ARRAY *Oj_Get_Lines(void *file) {
  YO_ARRAY *arr = Array_Pchars();
  char *S;
  while ((  S = Oj_Read_Line(file) )) Array_Push(__Retain(S));
  return arr;
}

YO_ARRAY *arr = Oj_Get_Lines(Cfile_Open("file","r"));

или

char lines[] = "line1\nline2\nline3";
YO_ARRAY *arr = Oj_Get_Lines(Memory_As_File(lines,strlen(lines)));

или с любого объекта который реализует протокол чтения строки.

As an example, to provide basic functionality for selected sparse matrix
types, the NIST implementation of the Sparse BLAS [18] contains over 10,000 routines and
a code generation system.

SN>В гугл

P>во-вторых, мы вроде про оптимизацию говорим, и видимо по скорости, не? Ну а если нужна оптимизация по размеру — то и она получится лучше и безопасней на C++

template<typename T>
inline const T& max(const T &a, const T &b)
{
    return (a<b) ? b : a;
}

YO_ARRAY *Oj_Get_Lines(void *file) {
  YO_ARRAY *arr = Array_Pchars();
  char *S;
  while ((  S = Oj_Read_Line(file) )) Array_Push(__Retain(S));
  return arr;
}

Ну, по причине неадекватной сложности, ведущей к постоянной борьбе с языком, и постоянного вынужденного скатывания к [b]синтаксическому...

int get_lines_as_strings(FILE *, char const *const **); // возвращает количество строк

struct strings {
    int num; // количество строк
    char const *const *str;
};

void get_lines_as_strings(FILE *, struct strings *);

struct strings {
    int num; // количество строк
    char const *const *str;
};

struct string get_lines_as_strings(FILE *);

vector<string> get_lines_as_strings(istream&);

class my_vector_impl {
    friend class my_vector;
    . . .
    void* f(void*);
    . . .
};

template <class T>
class my_vector {
    my_vector_impl impl_;
public:
    . . .
    T* f(T* p) { return reinterpret_cast<T*>(impl_.f(p)); }
    . . .

Array *read_lines(void *file)
{
    Array *lines = Strings();
    char *line;
    while( (line = read_line(file)) )
        array_push(retain(line));
    return lines;
}

Array *lines = read_lines(open_file("file","r"));

или

char lines[] = "line1\nline2\nline3";
Array *lines = read_lines(memory_as_file(lines,strlen(lines)));

P>у тебя макросы запрятаны в yoyo lib, что мешает запрятать обвёртки C++ в либу, или даже использовать готовые?

std::unique_ptr<MyySuperType> a(new MySuperType);

P>В C++ никто не заставляет тебя использовать non-intrusive'ные traits.

I>vector<string> get_lines_as_strings(istream&);
I>

1. array_type * get_lines_as_strings ( istream&, error_info * error = 0 );
2. error_code get_lines_as_strings ( istream&, array_type * strings );
3. исключения через long_jmp

NB>1. array_type * get_lines_as_strings ( istream&, error_info * error = 0 );

if(condition)
    {
    stmt1;
    stmt2;
    ...
    }

typedef std::vector<std::string> string_list;

void read_lines(std::istream& from, string_list& to)
{
    std::string buf;
    while (std::getline(from, buf))
        to.push_back(buf);
}

typedef std::vector<std::string> string_list;

void read_lines(std::istream& from, string_list& to)
{
    std::string buf;
    while (std::getline(from, buf))
        to.push_back(buf);
}

YO_ARRAY *Oj_Get_Lines(void *file) {
  YO_ARRAY *arr = Array_Pchars();
  char *S;
  while ((  S = Oj_Read_Line(file) )) Array_Push(__Retain(S));
  return arr;
}

Component Object Model (COM) is a binary-interface standard for software componentry introduced by Microsoft in 1993. It is used to enable interprocess communication and dynamic object creation in a large range of programming languages.