Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 5.00/4: Рейтинг темы: голосов - 4, средняя оценка - 5.00
36 / 29 / 2
Регистрация: 01.08.2011
Сообщений: 176
1

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

23.03.2015, 09:19. Просмотров 733. Ответов 8
Метки нет (Все метки)

Пытаюсь создать альтернативный оператор выделения памяти для своей библиотеки. С целью получить возможность передавать дополнительную информацию о типах в свой диспетчер памяти. Сначала сделал так:
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 (но не совпадающие с русскими буквами). Удобно использовать для каких-либо дополнительных соглашений о именовании.

0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
23.03.2015, 09:19
Ответы с готовыми решениями:

Чем отличается шаблонный метод класса от шаблонного класса?
Чем отличается шаблонный метод класса от шаблонного класса???????ПЛИЗ!!!!Если можно немного ссылок...

Шаблонный метод шаблонного класса
template &lt;class T1&gt; class A{ public: A(){}; void f(); }; template &lt;class T1,class T2&gt;...

Шаблонный метод присваивания шаблонного класса
привет. в некоторых классах пишут шаблонные методы присваивания, чтобы выполнять нечто такое: ...

Шаблонный метод без шаблонного класса
Доброго времени суток, можно ли сделать подобное? class ClassA { template &lt;class T&gt; T...

8
Форумчанин
Эксперт CЭксперт С++
8147 / 4997 / 1436
Регистрация: 29.11.2010
Сообщений: 13,460
23.03.2015, 09:23 2
Я так и не понял, чем не понравилась нормальная перегрузка операторов new/delete, new[]/delete[] ?
Цитата Сообщение от Виктор_Сен Посмотреть сообщение
Был в шоке от того, что знак © компилятор нормально воспринимает в именах, и ещё некоторые подобные знаки с кодами до 255 (но не совпадающие с русскими буквами).
В студии можно писать в юникоде.
1
DrOffset
23.03.2015, 09:34
  #3

Не по теме:

Цитата Сообщение от Виктор_Сен Посмотреть сообщение
Удобно использовать для каких-либо дополнительных соглашений о именовании.
Лучше так не делать. Приколотишь намертво гвоздями свой код к одному компилятору.

0
36 / 29 / 2
Регистрация: 01.08.2011
Сообщений: 176
23.03.2015, 10:01  [ТС] 4
Цитата Сообщение от MrGluck Посмотреть сообщение
Я так и не понял, чем не понравилась нормальная перегрузка операторов new/delete, new[]/delete[]
Это долгая история. У меня нетривиальный диспетчер памяти, которому нужна дополнительная информация, связанная с типами (в данном случае сделано через шаблоны). Можно конечно перегрузить new с дополнительными параметрами, но это не всегда удобно, т. к. для разных типов параметры свои. Причём оператор должен работать и со стандартными типами данных (int, float ...), и при этом должен быть локализован в библиотеке, чтобы этот нетривиальный диспетчер памяти не мог нарушить работу сторонних библиотек... И также я потом в конце добавил, что надо иметь возможность инициализировать массив константой или массивом параметров (чего нельзя сделать через стандартный new[], даже если его сделать перегруженным с параметрами, ведь эти параметры будут зависеть от конструктора создаваемого объекта...).

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

Добавлено через 4 минуты
Если бы new глобальный можно было локализовать в namespace, это бы разрешило большую часть проблем.
0
12128 / 6633 / 1601
Регистрация: 30.01.2014
Сообщений: 10,849
23.03.2015, 10:59 5
Цитата Сообщение от Виктор_Сен Посмотреть сообщение
Главное, чтобы код с таким смыслом компилировался.
Ну если хочется поизвращаться, то можно вот так:
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
Прошу не обращать внимания на трюки с памятью (при конструировании массива), это только лишь для демонстрации.
2
В астрале
Эксперт С++
8019 / 4776 / 654
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
23.03.2015, 11:00 6
Виктор_Сен, Что-то вы странное все-таки делаете. _new/_dlt всякие...
0
36 / 29 / 2
Регистрация: 01.08.2011
Сообщений: 176
23.03.2015, 11:10  [ТС] 7
В общем вот что получилось (для конструктора без параметров и с одним параметром):
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. Ну и ещё на основе этого можно сделать инициализацию массивом, если написать ещё перегрузку в последнем случае под указатель. Плохо то, что для конструктора с определённым числом параметров должен быть свой перегруженный шаблон. Но, это может в будущем сэкономить кучу кода (если учесть что параметры могут быть любые).
0
Миниатюры
Шаблонный оператор не шаблонного класса  
36 / 29 / 2
Регистрация: 01.08.2011
Сообщений: 176
23.03.2015, 11:21  [ТС] 8
Цитата Сообщение от ForEveR Посмотреть сообщение
Что-то вы странное все-таки делаете. _new/_dlt всякие...
Это собственные операторы, аналогичные new и delete... Вот и всё собственно. UPD: которые теперь умеют массив инициализировать константой или другим массивом (размеры должны совпадать).

Добавлено через 9 минут
UPD2: И которым не обязательно соответствие _new [] и _dlt [], то есть можно вызвать _new[], а удалить _dlt.
0
12128 / 6633 / 1601
Регистрация: 30.01.2014
Сообщений: 10,849
23.03.2015, 11:27 9
Цитата Сообщение от Виктор_Сен Посмотреть сообщение
В общем вот что получилось
Ну в общем-то в основе своей твой код использует ту же идею, что у меня. Только ты не используешь возможности С++11. В принципе, если подключить boost, то можно сделать практически так же компактно и на С++03 (tuple там есть, а нагенерировать специализаций под разное количество аргументов можно с помощью препроцессора).
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
23.03.2015, 11:27

Заказываю контрольные, курсовые, дипломные и любые другие студенческие работы здесь.

Шаблонный класс от шаблонного класса, ругается компоновщик
абстрактный класс Хэширования template &lt;class typeHashData, class typeHashIndex&gt; class...

Для шаблонного класса перегрузить оператор присваивания, copy-конструктор, объекты cin и cout, оператор *
Помогите в следующем: Для класса шаблона следует перегрузить оператор присваивания, конструктор...

Оператор индексации и присваивания для шаблонного класса Vector C++
Было задание разработать шаблонный класс Vector и к нему перегрузить оператор таким боразом, чтобы...

Как корректно передать в метод шаблонного класса объект шаблонного класса в качестве параметра?
header.h template &lt;class T&gt; class MyVector { public: void swap(MyVector&lt;T&gt;Vector); }...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
9
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2020, vBulletin Solutions, Inc.