Шаблонный оператор не шаблонного класса

@Виктор_Сен · Регистрация: 01.08.2011

Студворк — интернет-сервис помощи студентам

Пытаюсь создать альтернативный оператор выделения памяти для своей библиотеки. С целью получить возможность передавать дополнительную информацию о типах в свой диспетчер памяти. Сначала сделал так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    template<
        typename T
    > T* _new(
    )
    {
        T* t=_I::_mem_alloc<T>();
        return new(t) T(
            );
    }
 
    template<
        typename T,
        typename P00
    > T* _new(
    P00 p00
    )
    {
        T* t=_I::_mem_alloc<T>();
        return new(t) T(
            p00
            );
    }

Здесь код для конструкторов без параметров и с одним параметром. Для нескольких параметров делается аналогично (у меня в библиотеке сделано максимум на 10 параметров у конструктора). Детали функции-шаблона "_I::_mem_alloc<T>();" здесь не важны. И это работает нормально. Примерно так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
    TestClass* test_class=_new<TestClass>(7);
    TestClass* test_class0=_new<TestClass>();
    _dlt(test_class);
    _dlt(test_class0);
 
    system("pause");
    return 0;
}

Функция _dlt тоже своя, и с ней проблем нет. Теперь вопрос. Далее, я хочу сделать, чтобы мой оператор понимал ещё квадратные скобки, чтобы можно было создавать массивы. Пока я только сделал аналогичный оператор _newv, где первым дополнительным параметром передаётся размер массива. Но это не очень наглядно. Я бы хотел размер массива передавать в квадратных скобках. Пока единственный вариант у меня как это сделать - создать фиктивный класс-функтор с перегруженным оператором []. Примерно так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
    class ©new
    {
    public:
        template<typename T> T* operator()()
        {
            return new T();
        }
        ©new& operator[](int size)
        {
            std::cout<<"My mem dispatcher getting array size ="<<size<<std::endl;
            return _new_new;
        }
    }_new_new;

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
 
    TestClass* tc=_new_new<TestClass>()[5];//ERROR!!!!
 
    system("pause");
    return 0;
}

Это только набросок. Здесь реально размер массива не передаётся, но это дальше дело техники. Главное, чтобы код с таким смыслом компилировался. Но проблема в том, что компилятор ругается на параметр шаблона TestClass в этой строке"TestClass* tc=_new_new<TestClass>()[5];//ERROR!!!!". Если класс сделать не функтором, то этой проблемы не будет, но мне надо обращаться по имени объекта, чтобы не нарушать семантику библиотеки. Вопрос: в какой ещё позе (которая не снилась создателям камасутры) можно использовать C++, чтобы конструкция, аналогичная этой (с квадратными скобками) работала нормально?

Добавлено через 9 минут
Синтаксис с массивами нужен, чтобы потом реализовать такую вещь, как инициализацию массива константой или инициализацию массива другим массивом параметров (чего очень нехватает для стандартного оператора new).

Добавлено через 25 минут

Не по теме:

Был в шоке от того, что знак © компилятор нормально воспринимает в именах, и ещё некоторые подобные знаки с кодами до 255 (но не совпадающие с русскими буквами). Удобно использовать для каких-либо дополнительных соглашений о именовании.

MrGluck · 23.03.2015, 09:23

Я так и не понял, чем не понравилась нормальная перегрузка операторов new/delete, new[]/delete[] ?

Сообщение от Виктор_Сен

Был в шоке от того, что знак © компилятор нормально воспринимает в именах, и ещё некоторые подобные знаки с кодами до 255 (но не совпадающие с русскими буквами).

В студии можно писать в юникоде.

@DrOffset · 23.03.2015, 09:34

Не по теме:

Сообщение от Виктор_Сен

Удобно использовать для каких-либо дополнительных соглашений о именовании.

Лучше так не делать. Приколотишь намертво гвоздями свой код к одному компилятору.

@Виктор_Сен · 23.03.2015, 10:01 **[ТС]**

Сообщение от MrGluck

Я так и не понял, чем не понравилась нормальная перегрузка операторов new/delete, new[]/delete[]

Это долгая история. У меня нетривиальный диспетчер памяти, которому нужна дополнительная информация, связанная с типами (в данном случае сделано через шаблоны). Можно конечно перегрузить new с дополнительными параметрами, но это не всегда удобно, т. к. для разных типов параметры свои. Причём оператор должен работать и со стандартными типами данных (int, float ...), и при этом должен быть локализован в библиотеке, чтобы этот нетривиальный диспетчер памяти не мог нарушить работу сторонних библиотек... И также я потом в конце добавил, что надо иметь возможность инициализировать массив константой или массивом параметров (чего нельзя сделать через стандартный new[], даже если его сделать перегруженным с параметрами, ведь эти параметры будут зависеть от конструктора создаваемого объекта...).

В общем, по-моему у меня получилось кое-что, если фиктивный класс разделить на 2 компоненты... Сейчас напишу, что получилось.

Добавлено через 4 минуты
Если бы new глобальный можно было локализовать в namespace, это бы разрешило большую часть проблем.

@DrOffset · 23.03.2015, 10:59

Сообщение от Виктор_Сен

Главное, чтобы код с таким смыслом компилировался.

Ну если хочется поизвращаться, то можно вот так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <iostream>
#include <tuple>
#include <memory>
#include <cstring>
 
class TestClass
{
public:
    TestClass(int x)
    {
        std::cout << "TestClass(" << x << ")" << std::endl;
    }
    TestClass()
    {
        std::cout << "TestClass()" << std::endl;
    }
    ~TestClass()
    {
        std::cout << "~TestClass()" << std::endl;
    }
};
 
template <size_t... Indexes>
struct indexes {};
 
template <size_t N, size_t... Indexes>
struct make_indexes
    : make_indexes<N - 1, N - 1, Indexes...>
{};
 
template <size_t... Indexes>
struct make_indexes<0, Indexes...>
    : indexes<Indexes...>
{};
 
template <typename T, typename TupleT, size_t... Indexes>
T * create(TupleT && t, indexes<Indexes...>)
{
    return new T(std::get<Indexes>(std::forward<TupleT>(t))...);
}
 
template <typename T, typename TupleT, size_t... Indexes>
T * create(size_t size, TupleT && t, indexes<Indexes...>)
{
    //Warning!!! It is not legal code if it used with standard delete[],
    //but it works on most implementations
    void * raw = ::operator new(sizeof(T) * size + sizeof(size));
    std::memcpy(raw, &size, sizeof(size));
    void * mem = static_cast<uint8_t *>(raw) + sizeof(size);
    T * elems = static_cast<T *>(mem);
    for(size_t i = 0; i < size; ++i)
    {
        ::new(elems + i) T(std::get<Indexes>(std::forward<TupleT>(t))...);
    }
    return elems;
}
 
template <typename T, typename ...Args>
struct constructor
    : std::tuple<Args...>
{
    constructor(Args const & ...args)
        : std::tuple<Args...>(args...)
    { }
 
    operator std::unique_ptr<T>() const
    {
        return std::unique_ptr<T>(create<T>(*this, make_indexes<sizeof...(Args)>()));
    }
 
    std::unique_ptr<T[]> operator[](size_t size) const
    {
        return std::unique_ptr<T[]>(create<T>(size, *this, make_indexes<sizeof...(Args)>()));
    }
};
 
template <typename T, typename ...Args>
constructor<T, Args...> construct(Args const & ...args)
{
    return constructor<T, Args...>(args...);
}
 
int main()
{
    std::unique_ptr<TestClass> tc1 = construct<TestClass>(5);
    std::unique_ptr<TestClass> tc2 = construct<TestClass>();
    std::unique_ptr<TestClass[]> tc3 = construct<TestClass>()[5];
    std::unique_ptr<TestClass[]> tc4 = construct<TestClass>(10)[5];
}

http://rextester.com/ZDKR84063
Прошу не обращать внимания на трюки с памятью (при конструировании массива), это только лишь для демонстрации.

@ForEveR · 23.03.2015, 11:00

Виктор_Сен, Что-то вы странное все-таки делаете. _new/_dlt всякие...

@Виктор_Сен · 23.03.2015, 11:10 **[ТС]**

В общем вот что получилось (для конструктора без параметров и с одним параметром):

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    template<typename T, typename P0=void> class _new_for_index;
 
    template<typename T, typename P0> _new_for_index<T,P0> _new(P0);
 
    template<typename T> class _new_for_index<T>
    {
    public:
        T* operator[](int size)
        {
            std::cout<<"Creation aray of T, size = "<<size<<std::endl;
            T* temp=(T*)::operator new(size*sizeof(T));
            for (int i=0; i<size; i++)
            {
                new(&temp[i]) T();
            }
            return temp;
        }
        operator T*()
        {
            std::cout<<"Creation T"<<std::endl;
            return new T();
        }
    private:
        template<typename T> friend _new_for_index<T> _new();
        _new_for_index(){}
    };
 
    template<typename T, typename P0> class _new_for_index
    {
    public:
        T* operator[](int size)
        {
            std::cout<<"Creation aray of T, size = "<<size<<std::endl;
            T* temp=(T*)::operator new(size*sizeof(T));
            for (int i=0; i<size; i++)
            {
                new(&temp[i]) T(p0);
            }
            return temp;
        }
        operator T*()
        {
            std::cout<<"Creation T"<<std::endl;
            return new T(p0);
        }
    private:
        template<typename T, typename P0> friend _new_for_index<T,P0> _new(P0);
        _new_for_index(P0 p0™)
        {
            p0=p0™;
        }
        P0 p0;
    };
 
    template<typename T> _new_for_index<T> _new()
    {
        return _new_for_index<T>();
    }
 
    template<typename T, typename P0> _new_for_index<T,P0> _new(P0 p0)
    {
        return _new_for_index<T,P0>(p0);
    }

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
    TestClass* test_class=_new<TestClass>(7);
    TestClass* test_class0=_new<TestClass>();
    
    TestClass* tc=_new<TestClass>()[5];
    TestClass* tc2=_new<TestClass>(2)[5];
 
    system("pause");
    return 0;
}

Это в сыром варианте. Без delete ещё. Массив инициализируется константой. Создаётся временный объект с копией параметра иницализации. Это не очень хорошо, можно хранить указатель во временном объекте _new_for_index. Ну и ещё на основе этого можно сделать инициализацию массивом, если написать ещё перегрузку в последнем случае под указатель. Плохо то, что для конструктора с определённым числом параметров должен быть свой перегруженный шаблон. Но, это может в будущем сэкономить кучу кода (если учесть что параметры могут быть любые).

@Виктор_Сен · 23.03.2015, 11:21 **[ТС]**

Сообщение от ForEveR

Что-то вы странное все-таки делаете. _new/_dlt всякие...

Это собственные операторы, аналогичные new и delete... Вот и всё собственно. UPD: которые теперь умеют массив инициализировать константой или другим массивом (размеры должны совпадать).

Добавлено через 9 минут
UPD2: И которым не обязательно соответствие _new [] и _dlt [], то есть можно вызвать _new[], а удалить _dlt.

@DrOffset · 23.03.2015, 11:27

Сообщение от Виктор_Сен

В общем вот что получилось

Ну в общем-то в основе своей твой код использует ту же идею, что у меня. Только ты не используешь возможности С++11. В принципе, если подключить boost, то можно сделать практически так же компактно и на С++03 (tuple там есть, а нагенерировать специализаций под разное количество аргументов можно с помощью препроцессора).

Новые блоги и статьи Все статьи Все блоги /
Символьное дифференцирование igorrr37 13.02.2026 / * Программа принимает математическое выражение в виде строки и выдаёт его производную в виде строки и вычисляет значение производной при заданном х Логарифм записывается как: (x-2)log(x^2+2) -. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .	И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»
SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL3_image 8Observer8 10.02.2026 Содержание блога Библиотека SDL3_image содержит инструменты для расширенной работы с изображениями. Пошагово создадим проект для загрузки изображения формата PNG с альфа-каналом (с прозрачным. . .	Установка Qt-версии Lazarus IDE в Debian Trixie Xfce volvo 10.02.2026 В общем, достали меня глюки IDE Лазаруса, собранной с использованием набора виджетов Gtk2 (конкретно: если набирать текст в редакторе и вызвать подсказку через Ctrl+Space, то после закрытия окошка. . .

@ForEveR В астрале 8049 / 4806 / 655 Регистрация: 24.06.2010 Сообщений: 10,562
	23.03.2015, 11:00
	Виктор_Сен, Что-то вы странное все-таки делаете. _new/_dlt всякие... 0