Есть такая проблема:

int *func(void);
void main(void)
{
    int mass[10];
....
   mass=func();
}
int* func(void)
{
   int ret[10];
   ....
  return ret;
}

VC-шный компилятор ругается на функцию, возвращающую указатель (func()) — типа нельзя возвращать указатель на локальную переменную.
Что, в общем, правильно и понятно.
Есть два выхода — либо заводить глобальный массив (чего очень как не охота), либо заводить структуру (struct ....),динственным членом которой является массив и заставлять функцию возвращать эту структуру (что, как мне кажется, тоже не очень хорошо).
Вопрос такой: насколько ликвиден второй способ (на котором я и остановился) и какие еще есть варианты?

Здравствуйте Alick, Вы писали:

A>какие еще есть варианты?

int *func(void);
void main(void)
{
    int* mass = NULL;
....
   mass=func();
}

int* func(void)
{
   int* ret = new int[10];
   ....
  return ret;
}

Здравствуйте Alick, Вы писали:

Динамически распределяя память, передавая указатель на нее той самой структуре, о которой ты говоришь, мы приходим к концепции умного указателя. Если еще и эту самую структуру заставить полностью управлять распрелдделением памяти, то это будет уже "ведущий указатель". Как видишь, этим методам даже названия придумали, так-что способ ликвидный.

Дополнительный способ- распределять память не внутри функции, а снаружи (сам догадался наверное). Тогда нет таких проблем.

Здравствуйте Kaa, Вы писали:

Kaa>Дополнительный способ- распределять память не внутри функции, а снаружи (сам догадался наверное). Тогда нет таких проблем.

Тупой — не понял
Передавать возвращаемый массив в аргументах функции чтоли?

Здравствуйте Alick, Вы писали:

A>и какие еще есть варианты?

int *func(void);
void main(void)
{
    int *mass;
....
   mass=func();
}
int* func(void)
{
   static int ret[10];
   ....
  return ret;
}

Судя по коду Вам необходимо в функции func заполнить mass некоторыми значениями? Если моя догадка верна, то, как сказал Kaa, легче переписать сигнатуру функции func и передавать указатель на массив.

int* func(int size, int *arr)
{
   for( int i = 0; i < size; i++ )
   {
      // делаем здесь что-нибудь c i-ым элементом, например 
      arr[i] = i;
   }
   return arr;
}
void main(void)
{
   int mass[10];

   func(sizeof(mass), mass);
}

Если я не прав, то прошу уточнить задачу?

Здравствуйте Alick, Вы писали:

Kaa>>Дополнительный способ- распределять память не внутри функции, а снаружи (сам догадался наверное). Тогда нет таких проблем.

A>Передавать возвращаемый массив в аргументах функции чтоли?
Типа. Только распределять его снаружи, а не внутри.

void f( int* p, size_t sz ) ...
...
int arr[10];
...
f( arr );

Чтоб наружу что-то передавать, надо весь объект копировать. Для больших объектов это не есть гуд, посему придумали такую фишку, как всякие умные указатели. Ну, сам знаешь наверное.

Здравствуйте Kaa, Вы писали:

Kaa>Если еще и эту самую структуру заставить полностью управлять распрелдделением памяти, то это будет уже "ведущий указатель".

А как структуру заставить управлять распределением памяти?

Здравствуйте Alick, Вы писали:

A>А как структуру заставить управлять распределением памяти?
Я не имел ввиду "структуру в смысле struct, а лишь нечто составное.

Ну, если мы говорим о С++ (а не о С), то делаем следующее:

class CSome
{
public:
  CSome( int size ) : p( 0 ), sz( size ) { p = new int[a]; }
  ~CSome() { delete p; }
...
  operator int*() { return p; }
  operator const int*() const { return p; }

private:
  int* p;
  int  sz;
};

Тогда использовать его можно было бы примерно так:

void f( int* p, int sz )
{
// делать что-то с массивом интов длинны sz
}

void g()
{
  CSome some( 10 );
  f( some, 10 );
}

Внутрь f() передается указатель на память, которой владеет экземпляр some класса CSome.

Для полноты картины нужно еще всяких недостающих операций доопределять.

Здравствуйте Kaa, Вы писали:

Kaa>Ну, если мы говорим о С++ (а не о С), то делаем следующее:

увы... проблема была как сделать именно в С.

В общем, спасибо большое за помощь.