Ошибка при попытке создания шаблона

@_20_ · Регистрация: 29.09.2011

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

В чём ошибка?
Функции
Map::isGardenWithoutWallFlag, Map::setNothing, Map::incrementRoad, Map::setFlagWall
имеют действительно такие аргументы, какие надо. Ошибка появилась, как только я добавил в шаблон двойной указатель на int.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template<bool (*func1)(int), void (*func2)(int&), void (*func3)(int&, eDirection),
          void(*func4)(int&), int** tileMap>
static void threeFuncTrySet(int x, int y, eDirection d){
    if(func1(tileMap[x][y])){
        func2(tileMap[x][y]);
        func3(tileMap[x][y], d);
        func4(tileMap[x][y]);
    }
}
 
 
void aabb (int** tileMap){
 
void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<&Map::isGardenWithoutWallFlag, 
        &Map::setNothing, &Map::incrementRoad, &Map::setFlagWall, tileMap>;
 
}

@hoggy · 16.11.2014, 15:11

Мне не удалось понять причину такого странного поведения.

Однако, я могу предложить вам использовать обходной путь:

http://rextester.com/MNPP22406

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
#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        class Pointer2Pointer
    >
    static void threeFuncTrySet(int x, int y, eDirection d)
    {
        typedef typename ::std::remove_pointer<Pointer2Pointer>::type
            Pointer;
            
        static_assert( ::is_pointer<Pointer>::value, 
            "ERROR: invalid type Pointer2Pointer" );
            
        typedef typename ::std::remove_pointer<Pointer>::type
            Value;
            
        static_assert( !::is_pointer<Value>::value && ::std::is_object<Value>::value, 
            "ERROR: invalid type Pointer2Pointer" );
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap)
{
    
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**
    >;
    
    (void)treeFunc;
 
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

/ps Очень неудобно и хлопотно вручную восстанавливать недостающие элементы кода, что бы как то заставить его компилироваться.

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

Добавлено через 6 минут
Простите, выше указанный вариант - кривой.
Вот более простой и правильный:

http://rextester.com/BORIV94479

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
#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T
    >
    static void threeFuncTrySet(int, int, eDirection)
    {
        static_assert( ::std::is_same<T, int**>::value, 
            "ERROR: parameter T must be int**");
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap)
{
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**
    >;
    (void)treeFunc;
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

@_20_ · 16.11.2014, 15:59 **[ТС]**

Мне кажется, что Вы решили немного иную задачу. Мне надо было передавать передать какой - то определённый указатель, а не тип указателя. Я конечно - же мог бы его передавать как аргумент, но это не совсем удобно.

@DrOffset · 16.11.2014, 16:01

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

Мне не удалось понять причину такого странного поведения.

Ничего в этом странного нет. Аргументами шаблона могут быть только известные на этапе компиляции величины: Либо константы времени компиляции, либо указатели на функции, либо указатели на методы, либо сonstexpr выражения. Указатели на объекты становятся известны только на этапе выполнения, поэтому аргументом шаблона быть не могут.

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

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

Мне надо было передавать передать какой - то определённый указатель, а не тип указателя.

Указатель передавай аргументом (параметром) функции.
Т.е. так:

C++
1
2
template<bool (*func1)(int), void (*func2)(int&), void (*func3)(int&, eDirection), void(*func4)(int&)>
static void threeFuncTrySet(int x, int y, eDirection d, int** tileMap)

@_20_ · 16.11.2014, 16:21 **[ТС]**

Аргументами шаблона могут быть только известные на этапе компиляции величины:

Спасибо большое, всегда об этом забываю.

Добавлено через 11 минут
Нет ли какого - нибудь механизма, чтобы всё - таки сделать это?
То есть один раз подать указатель, а потом несколько раз использовать функцию, не подавай повторно.
Я сейчас думаю что - то типа такого:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T
    >
class Obj{
   int** tileMap;
   Obj(int** t): tileMap(t){}
   void doThis(int x, int y, eDirection d){
      if(func1(tileMap[x][y])){
         func2(tileMap[x][y]);
         func3(tileMap[x][y], d);
         func3(tileMap[x][y]);
      }
   }
}

Что вы думаете об этом? Если ли какие - нибудь минусы по сравнению с передачей указателя как аргумента?

@DrOffset · 16.11.2014, 16:28

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

Что вы думаете об этом?

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

@hoggy · 16.11.2014, 16:51

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

Указатели на объекты становятся известны только на этапе выполнения, поэтому аргументом шаблона быть не могут.

int** - это тип.
Параметром шаблона может быть тип.

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

Мне надо было передавать передать какой - то определённый указатель, а не тип указателя. Я конечно - же мог бы его передавать как аргумент, но это не совсем удобно.

В этом случае существует ограничение: параметром шаблона, не являющимся типом может быть интегральная константа времени компиляции.

Это означает, что единственные объекты, которые на сегоднящний день можно передать через параметры шаблона должны иметь статический класс памяти: указатели на функции, или объекты фундаментальных типов с++:

http://rextester.com/MJHQA58643

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
#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
 
int value = 10;
int* pvalue = &value;  //<--- статическая переменная. 
     //Является фундаментальным типом с++.  
    //Можно передать в параметре шаблона
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T, T obj
    >
    static void threeFuncTrySet(int, int, eDirection)
    {
        static_assert( ::std::is_same<T, int**>::value, 
            "ERROR: parameter T must be int**");
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap) //<--- аргумент функции нельзя использовать в параметрах шаблона
{                                
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**, 
        &pvalue  //<--- статическая переменная. Можно.
    >;
    (void)treeFunc;
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

@DrOffset · 16.11.2014, 16:57

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

Параметром шаблона может быть тип.

Может. Но здесь параметр шаблона не тип, а объект типа. Смотри внимательнее.

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

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

Это означает, что единственные объекты, которые на сегоднящний день можно передать через параметры шаблона должны иметь статический класс памяти

Вот именно. В примере ТСа же передается переменная-аргумент функции, что недопустимо. Опять же нет никаких противоречий с тем, что я написал. Переменные со статическим классом памяти имеют фиксированные адреса, известные на этапе компиляции, поэтому это допускается. В примере ТСа передается объект, с адресом известным лишь в runtime, поэтому его код не прошел.

@hoggy · 16.11.2014, 17:11

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

Переменные со статическим классом памяти имеют фиксированные адреса, известные на этапе компиляции, поэтому это допускается.

Не верно.
Они не известны времени компиляции.
Поэтому, значение нельзя использовать в выражениях времени компиляции.

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

Значение адресов известны только на этапе линковки.

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

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

Но здесь параметр шаблона не тип, а объект типа. Смотри внимательнее.

Да, действительно. Спасибо за наводку.

В общем, параметром шаблона может быть либо формальный параметр:

< typename T>
<class U>

либо шаблонный параметр:

< template< class U> class T>

либо интегральная константа:

< typename C, C c>

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

@DrOffset · 16.11.2014, 17:27

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

Не верно.

Согласен. Однако, в общем-то это не играет здесь роли (с моими собственными пробелами я справлюсь самостоятельно), т.к. объект, передаваемый ТСом имел автоматический класс хранения и никак не мог являться аргументом шаблона, и раз уж ты разбираешься в этом вопросе, то мне так и не понятно в чем причина характеристики этого поведения как "странного"?

@hoggy · 16.11.2014, 17:45

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

то мне так и не понятно в чем причина характеристики этого поведения как "странного"?

Не обращайте внимания, я иногда после многочасовых марафонов начинаю затуплять на ровном месте.

У меня в голове щелкнуло "int** - это тип, следовательно, можно использовать там, где можно использовать тип".

Просто устал.

@DrOffset · 16.11.2014, 18:02

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

Не обращайте внимания

Ладно, это понятно.

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

Не верно.
Они не известны времени компиляции.

В общем, вот что: ты конечно прав здесь. Но и нельзя сказать, что я был совсем не прав. На этапе компиляции конкретный адрес неизвестен, однако известен некий символ, который потом можно заменить на реальный адрес (что линкер и делает). В новом стандарте пример, который ты привел в опровержение, работает.
Есть вот такой текст (14.3.2):

a constant expression (5.19) that designates the address of an object with static storage duration and
external or internal linkage or a function with external or internal linkage, including function templates
and function template-ids but excluding non-static class members, expressed (ignoring parentheses) as
& id-expression, except that the & may be omitted if the name refers to a function or array and shall
be omitted if the corresponding template-parameter is a reference;

Как видно, здесь добавилась формулировка про internal linkage, которой раньше (в С++03) не было (раньше действительно можно было использовать в аргументов только адреса со static storage duration и external linkage).
Следовательно мы можем взять адрес статической функции использовать его в выражениях времени компиляции.

@hoggy · 16.11.2014, 18:18

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

На этапе компиляции конкретный адрес неизвестен, однако известен некий символ, который потом можно заменить на реальный адрес (что линкер и делает).

Ага.

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

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

Не уловил.

На самом деле на практике ничего не изменилось.
Мы по прежнему можем прокидывать некоторые объекты через параметры шаблона.
И по прежнему не можем использовать значения их адресов в выражениях времени компиляции.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
 
struct example
{
    static void gen(){}
    
    enum { id = &gen };
};
 
int main()
{
    std::cout << "Hello, world!\n";
}

Error(s):
source_file.cpp:10:18: error: enumerator value for ‘id’ is not an integer constant
enum { id = &gen };
^

Значением enum может быть только и только выражение времени компиляции.
Эксперимент наглядно показывает, что адреса функций не являются значениями времени компиляции.
Несмотря на то, что сам объект (указатель на функцию) является интегральной константой времени компиляции.

Прокидывать через аргументы шаблона можно. Использовать значение - нельзя.

@DrOffset · 16.11.2014, 18:43

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

Значением enum может быть только и только выражение времени компиляции.

Не совсем. Значением enum может быть только интегральная константа времени компиляции (указатель к таковым не относится).

A literal constant expression is a prvalue core constant expression of literal type, but not pointer type. An
integral constant expression is a literal constant expression of integral or unscoped enumeration type.

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

Эксперимент наглядно показывает, что адреса функций не являются значениями времени компиляции.

К сожалению нет. Смотри пожалуйста параграфы 5.19 и 14.3.2.

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

Использовать значение - нельзя.

Можно в constexpr выражениях.

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

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

Не уловил.

Может быть ты говорил о другом. Но изначально я думал, что ты о том, что аргументами шаблона в С++03 могут быть только объекты со статическим классом памяти и внешним связыванием. То есть extren. Когда ты сказал, что адрес статической функции не может быть аргументом шаблона, то я подумал что речь о внешних статических функциях, ведь static для них делает внутренее связывание. Т.е. вот такой код в С++03 приводил к ошибке:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*extern*/ int f1() // внешнее связывание
{
}
 
static int f2() // внутренее связывание
{
}
 
template <int (*v)()>
struct B
{
};
 
int main()
{
    B<&f1> c1; // OK
    B<&f2> c2; // ERROR
}

В рамках С++03 твой контраргумент про

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

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

был корректен (с оговоркой на шаблоны). Однако он уже совсем некорректен в рамках С++11.

@hoggy · 16.11.2014, 18:48

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

Не совсем. Значением enum может быть только интегральная константа времени компиляции (указатель к таковым не относится).

Вы сами себе противоречите.

Ваш первоначальный тезис:

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

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

И не нужно меня отсылать к стандарту.

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

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

Можно в constexpr выражениях.

Да. Однако ключевое слово constexpr - это просьба, а не приказ.
И не факт что компилятор подчинится:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
 
constexpr size_t foo() { return (size_t)&foo; }
 
struct example
{
    enum { it = foo() };
};
 
int main()
{
    std::cout << "Hello, world!\n";
}

source_file.cpp:8:21: error: conversion from pointer type ‘size_t (*)() {aka long unsigned int (*)()}’ to arithmetic type ‘size_t {aka long unsigned int}’ in a constant-expression
enum { it = foo() };

Если вы закомментируете строку

C++
1
enum { it = foo() };

То код скомпилируется.

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

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

Может быть ты говорил о другом.

Не путайте понятия "параметр шаблона", "тело шаблона", и "выражение времени компиляции".

Выражение времени компиляции - это операции производимые над константами времени компиляции.

Ну так вот, несмотря на то, что стандарт заявляет, что адреса функции - константы времени компиляции, мы все равно не можем использовать значения этих констант.

Только имена. Можем использовать их в параметрах шаблонов, или в туловище шаблона. Но не в выражениях времени компиляции.

@DrOffset · 16.11.2014, 19:03

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

Вы сами себе противоречите.

В чем? Я просто указал, что требования enum исходят не только из требования к времени компиляции, но и из требования к истинной целочисленности того, чем мы инициализируем его константы. Указатель в общем случае не может быть корректно скастован к целому числу.

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

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

C++
1
2
3
4
5
6
7
typedef int (*func_t)();
 
template <func_t a, func_t b>
struct C
{
    static constexpr func_t f_arr[] = { a, b };
};

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

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

Не путайте понятия "параметр шаблона", "тело шаблона", и "выражение времени компиляции".

Да ничего я не путаю

@hoggy · 16.11.2014, 19:12

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

В чем?

Ваш тезис:

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

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

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

Приведенный вами пример:

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

typedef int (*func_t)();
template <func_t a, func_t b>
struct C
{
* * static constexpr func_t f_arr[] = { a, b };
};

Никак не использует значения адреса
Не путайте тело шаблона и выражение времени компиляции.

Пример выражения времени компиляции:

C++
1
2
3
4
template<class T, bool is_int = ::std::is_same<int, T>::value >
struct example
{
};

Здесь в шапке шаблона,

C++
1
bool is_int = ::std::is_same<int, T>::value

Есть выражение времени компиляции.

Пример попытки использовать адрес функции в выражении времени компиляции я предоставил вам выше.
Естественно, пример не заработал.

@TheCalligrapher · 16.11.2014, 19:24

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

Выражение времени компиляции - это операции производимые над константами времени компиляции.

В терминологии языка С++ Отдельно стоящая константа - это тоже выражение, хоть в нем и нет никаких "операций".

Однако никто вам не запрещает получать адрес функции через применение оператора '&' -вот вам уже и выражение с оператором.

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

Ну так вот, несмотря на то, что стандарт заявляет, что адреса функции - константы времени компиляции, мы все равно не можем использовать значения этих констант.

Это какая то белиберда. "Не можем использовать" где именно? Как нетиповые параметры шаблонов - можем, конечно. Без проблем.

Так о чем идет речь? Что мы "не можем"?

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

Только имена. Можем использовать их в параметрах шаблонов, или в туловище шаблона. Но не в выражениях времени компиляции.

Это какая-то белиберда. Аргументы шаблонов - всегда выражения времени компиляции. Взятие адреса функции (что с оператором '&', что без) - выражение времени компиляции.

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

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

Здесь в шапке шаблона,

C++
1
bool is_int = ::std::is_same<int, T>::value

Есть выражение времени компиляции.

Выражением времени компиляции также является 'true' в

C++
1
bool is = true

Выражением времени компиляции также является 'foo' в

C++
1
void (*ptr)() = foo;

@DrOffset · 16.11.2014, 19:35

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

Не содержит выражения времени компиляции.

Не убедил. Почему выражение

C++
1
static constexpr func_t f_arr[] = { a, b };

Не может быть выражением времени компиляции? Допустим, я предполагаю, что действительно заблуждаюсь в этом вопросе.
Добавлено через 6 минут

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

Никак не использует значения адреса

Как же он его не использует, когда он из них (из значений) формирует массив?

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

Пример выражения времени компиляции:

Хорошо, вот пример по аналогии с твоим:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
typedef int ( *func_t)();
 
template <func_t a, func_t b, bool f>
struct C
{
    static constexpr func_t f = a;
};
 
template <func_t a, func_t b>
struct C<a, b, true>
{
    static constexpr func_t f = b;
};
 
template <typename T, func_t a, func_t v = C<a, &f2, std::is_integral<T>::value>::f>
struct B
{
};
 
int main()
{
    typedef B<int, f1> test_t;
}

@hoggy · 16.11.2014, 19:42

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

В терминологии языка С++ Отдельно стоящая константа - это тоже выражение, хоть в нем и нет никаких "операций".

Да. Но выражением времени компиляции это выражение будет только, если значение самой константы вычисляется времени компиляции.

Выражение времени компиляции - это выражение, результат которого известен времени компиляции.

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

Так о чем идет речь? Что мы "не можем"?

Речь конкретно об этом:

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

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

и об этом:

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

Взятие адреса функции (что с оператором '&', что без) - выражение времени компиляции.

Это не верно.

Потому что, если бы это было так, тогда значение адреса было бы известно времени компиляции, и его можно было бы использовать в выражениях времени компиляции.

Однако это не так, и пример с enum тому красноречивое подтверждение.

Вы конечно можете любую в принципе синтаксическую запись на зыке назвать "выражением времени компиляции".

Однако, не всякое выражение является выражением времени компиляции , и в этом смысле диалог не имеет смысла.

На практике смысл фразы "выражения времени компиляции" появляется тогда, и только тогда, когда мы, программисты, можем использовать их для своих целей: метапрограммирования, и компалтайм-алгоритмы.

Ну так вот, использовать адреса функция в компалтайм алгоритмах не получится.

Потому что в этих алгоритмах можно использовать только и только те выражения, результат которых известен времени компиляции.

Адрес функции времени компиляции не известен.
И поэтому, взятие адреса - есть выражение времени выполнения, а не компиляции.

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

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

Как же он его не использует, когда он из них (из значений) формирует массив?

Я вам ещё раз повторю:
1. constexpr это просьба, а не приказ.
2. Вы используете имя объекта, а не значение адреса.

Этого достаточно компилятору для того, что бы он смог построить туловище шаблона.
Но не достаточно для того, что бы результат выражения можно было бы использовать в компалтайм алгоритмах.

Поэтому я в третий раз повторюсь: не путаете понятие "выражение времени компиляции" и "тело шаблона".

Тело может быть каким угодно. И использовать конструкции, результат работы которых известен только времени выполнения.

Такие конструкции не являются выражением времени компиляции.

Новые блоги и статьи Все статьи Все блоги /
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 . Быстренько разберем подход "на фреймах". Мы делаем одну. . .

@_20_ 21 / 55 / 9 Регистрация: 29.09.2011 Сообщений: 617
	16.11.2014, 15:59 [ТС]
	Мне кажется, что Вы решили немного иную задачу. Мне надо было передавать передать какой - то определённый указатель, а не тип указателя. Я конечно - же мог бы его передавать как аргумент, но это не совсем удобно. 0

Ошибка при попытке создания шаблона

Решение