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

@Виктор_Сен · Регистрация: 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 там есть, а нагенерировать специализаций под разное количество аргументов можно с помощью препроцессора).

Новые блоги и статьи Все статьи Все блоги /
PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Access VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .
Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .	Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .

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