Можно ли создать следущюю конструкцию,
void* New(<type>, int size)
{
return (void*)(new <type>[size]);
}
New(int, 5);
где <type> — имя типа данных?

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

Ч>Можно ли создать следущюю конструкцию,
Ч>void* New(<type>, int size)
Ч>{
Ч> return (void*)(new <type>[size]);
Ч>}
Ч>New(int, 5);
Ч>где <type> — имя типа данных?

Что-то не ясен смысл в этом примере.

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

Ч>Можно ли создать следущюю конструкцию,
Ч>void* New(<type>, int size)
Ч>{
Ч> return (void*)(new <type>[size]);
Ч>}
Ч>New(int, 5);
Ч>где <type> — имя типа данных?
А зачем так? Если ты хочеше чтобы был тип массива в котором могут храниться любые типы, то используй шаблоны, например std::vector<T>, где T — это нужный тебе тип. Или я чего-то не понял?

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

__>Что-то не ясен смысл в этом примере.
Я хочу создавать массивы любых типов одной функцией, и причем тип передавать в живую.
Например,
void* a = New(int, 5); // a — это массив из целых чисел длинной 5 элеметов
void* b = New(double, 5);// b — это массив из double длинной 5 элеметов

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

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

__>>Что-то не ясен смысл в этом примере.
Ч>Я хочу создавать массивы любых типов одной функцией, и причем тип передавать в живую.
Ч>Например,
Ч>void* a = New(int, 5); // a — это массив из целых чисел длинной 5 элеметов
Ч>void* b = New(double, 5);// b — это массив из double длинной 5 элеметов

Обычный вызов new[] дает такой же результат:

void* a = new int[5];
void* b = new double[5];

А если вам надо работать с указателями то зачем их объявлять как void* ?

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

Ч>Можно ли создать следущюю конструкцию,
Ч>void* New(<type>, int size)
Ч>{
Ч> return (void*)(new <type>[size]);
Ч>}
Ч>New(int, 5);
Ч>где <type> — имя типа данных?

template <class type>
void* New(int size) {
    return (void*)(new type[size]);
}

// используем:
void* a = New<int>(5);

ты так хотел?

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

Ч>Можно ли создать следущюю конструкцию,
Ч>void* New(<type>, int size)
Ч>{
Ч> return (void*)(new <type>[size]);
Ч>}
Ч>New(int, 5);
Ч>где <type> — имя типа данных?
Тебе это надо было?

template <class T>
T* New(<type>, int size) {
    return new T[size];
}

А чем std::vector не устроил?

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

Извините, описка:
Вместо

T* New(<type>, int size) {

надо естественно

T* New(int size) {

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

Ч>Можно ли создать следущюю конструкцию,
Ч>void* New(<type>, int size)
Ч>{
Ч> return (void*)(new <type>[size]);
Ч>}
Ч>New(int, 5);
Ч>где <type> — имя типа данных?

Сделать то, что вы хотите, я не смог, но есть следующий вариант:

// main.cpp -----------------------------------------------
#include <cstdio>



template <class t, unsigned int size>
class array
 {
  public:
   //конструктор 
   array() { arrayPtr = new t [size]; }
   //деструктор
   ~array() { delete [] arrayPtr; }
   //не-const индексация
   t & operator[](unsigned int i) { return arrayPtr[i]; } 
   //const индексация
   const t & operator[](unsigned int i) const { return arrayPtr[i]; }
  private:
   t * arrayPtr;  
 }; 
 
 
 
int main()
 {
  array<int, 5> a;
  
  a[1] = 8;
  printf("a[1] is: %d\n", a[1]);
  getchar();
  return 0;
 } 
// конец main.cpp --------------------------------------------