Форум 'C/C++' на RSDN.RU

template в MSVC 6.0 и MSVC 2008

Tue, 09 Feb 2010 12:40:43 GMT

ошибся немного.. в предыдущем не так:
"
НО не выругалась так:

   MySimpleTemplate<int> x(45);
   int i;
   i = x;

"

а вот так :

"
НО не выругалась так:

   MySimpleTemplate<int> x(45);
   int i;
   i = x + 5;

Стандарт перевода wchar_t в char

Tue, 09 Feb 2010 07:33:53 GMT

Подскажите, гуру, что на данный момент является стандартом С++ преобразования из wchar_t в char?
Нарыл вагон примеров. Все работает, но мне надо для тестового задания точно знать, как ПРАВИЛЬНО и переносимо сделать преобразование.
Например, вывести в поток ofstream строку wchar_t (не двоичным образом, а предврительным преобразованием в char).
Заранее спасибо.

Об изучении STL

Mon, 08 Feb 2010 20:09:11 GMT

Пытаясь разобраться, как реализованы алгоритмы стандартной библиотеки, приходится продираться через заборы #ifdef, отладочных макросов, да и просто через, так сказать, своеобразный coding style (реализация от MS, другие пока не пробовал).
Тут же захотелось странного — а что, если создать реализацию STL (хотя бы только в виде контейнеры + алгоритмы), предназначенную исключительно для учебных целей — т.е. максимально прозрачный код, снабженный комментариями и документацией. Существует ли что-нибудь подобное?

Да, еще интересно — какая из книг по STL максимально описывает ее "внутренности"? Я понимаю, что существуют разные реализации, но на всех них налагает свои требования Стандарт, так что различия не должны быть принципиальны.

template в MSVC 6.0 и MSVC 2008

Mon, 08 Feb 2010 16:12:30 GMT

Добрый день!
не понятно поведение студий с таким кодом :

#include <iostream>
template <class T>
class MySimpleTemplate 
{
    T n;
public:
    explicit MySimpleTemplate ( T nn)
    {
        this->n = nn;
    }
    operator T & ()
    {
        return this->n;
    }
};

void main(void)
{
    MySimpleTemplate<int> x(45);
    int i = 16;
    x = i;
    x = i + 5;
    x = 15;
    std::cout << x << std::endl;
}

MSVC 6.0 ругаеться только на эту строчку :

x = i;

и перестаёт ругаться, если изменить строчку так :

(int &)x = i;

MSVC 2008 ругаеться же на всё ТРИ строчки :

x = i;
x = i + 5;
x = 15;

и опять же. перестаёт если так :

(int &)x = i;
(int &)x = i + 5;
(int &)x = 15;

намекните хоть что происходит???

08.02.10 20:17: Перенесено модератором из 'C/C++. Прикладные вопросы' — Кодт

непонятка со статическими переменными

Mon, 08 Feb 2010 15:02:27 GMT

Здравствуйте! Помогите разобраться, плиз.
Есть у класса такой метод:

// Сохранение значения прочитанной с оборудования переменной во внутреннем КЭШе (в соответствующем переменной тэге)
void COpcInnerTransaction::SaveValueInCache(CAddressSpace* pAddressSpace , VARIANT varValue)
{
    static CBoundaryNodeIndexes BoundaryNodes = pAddressSpace->getBoundaryNodeIndexes(m_DeviceID);

    static int CurrentIndex = BoundaryNodes.Start;
    static int EndIndex = BoundaryNodes.End;

    CurrentIndex = pAddressSpace->SaveValue(CurrentIndex, EndIndex, varValue);
}

Он вызывается несколько раз, затем экземпляр класса COpcInnerTransaction удаляется.

Через время N экземпляр вновь создается, и происходит серия аналогичных вызовов. Мне непонятно, почему уже при 1-м вызове значение всех статических переменных внутри метода равно тем значениям, которые были на последнем вызове до удаления объекта.
У меня ведь нестатический метод. И объект я удаляю из памяти! А потом создаю, и хоп! Функция все помнит. А мне ето не надо...

CStupidClassName

Sun, 07 Feb 2010 20:11:21 GMT

Повторение, как говорится, мать учения.

Попробовал собрать е-Мула 2010й Студией:

Error    2    error LNK2005: "public: virtual __thiscall CMemDC::~CMemDC(void)" (??1CMemDC@@UAE@XZ) already defined in ProgressCtrlX.obj    uafxcwd.lib(afxglobals.obj)    emule

Что же это? В MFC появился class CMemDC, а е-мул уже использует Flicker Free Drawing In MFC. Кому из них придётся подвинуться, в общем то и не вопрос.

Определить сравниваемость типов

Sun, 07 Feb 2010 11:04:07 GMT

Всем привет.

Задача проста, как пять копеек — есть 2 типа. Необходимо в компайл-тайм определить, сравниваемы ли они, т.е. можно ли, например, написать T1() == T2().
Попробовал поиграть со SFINAE, не работает (причем в комо и в VC8 не работает по разному):

struct X
{
};

template<int>
struct comp
{
};

template <class T, class U>
struct is_comparable
{
    typedef char no_type;
    struct yes_type
    {
        no_type data[2];
    };

    static no_type check(...);
    template <class T1, class U1>
    static yes_type check(T1 *, U1 *, comp<sizeof(T1() == U1())> * = 0);
    enum {value = sizeof(check((T *)0, (U *)0)) == sizeof(yes_type)};
};

int main()
{
    char t[is_comparable<int, X>::value];
    char t1[is_comparable<int, int>::value];
}

В комо результат всегда 0, в VC8 1. Есть ли шансы докрутить это до работоспособности или без вариантов?
Спасибо!

Отладка макросов

Sat, 06 Feb 2010 17:04:30 GMT

Как сделать чтобы Visual Studio 2008 видя что вызывается #define макрос при отладке входила в тело макроса?

запретить включать set в класс

Sat, 06 Feb 2010 00:00:17 GMT

привет всем!
такая задача по горячим следам:
есть Base и куча Derived. хотим запретить использовать класс set внутри новеньких.
использовать как

class DerivedNextGeneration : public Derived
{
...
set<int> * my_var // да!
set<int> my_var // нет!
...
}

измучился и никак не пойму, можно ли что-нибудь придумать.

спасибо еще раз всем за помощь!

Странные ошибки при сравнении std::string

Fri, 05 Feb 2010 18:40:29 GMT

Игрался с разными STL-ными контейнерами, и несколько раз напарывался на странные ошибки, практически на пустом месте. Например:

    priority_queue<string, deque<string> > pq2;
    // Что-то с оператором >?
    pq2.push("aaaa");
    pq2.push("bbbb");

За что нравятся шаблоны, такие понятные сообщения об ошибках:

c:\program files\microsoft visual studio 8\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::queue<_Ty,_Container> &,const std::queue<_Ty,_Container> &)' : could not deduce template argument for 'const std::queue<_Ty,_Container> &' from 'const std::basic_string<_Elem,_Traits,_Ax>'
with
[
_Elem=char,
_Traits=std::char_traits<char>,
_Ax=std::allocator<char>
]
c:\program files\microsoft visual studio 8\vc\include\queue(103) : see declaration of 'std::operator <'
c:\program files\microsoft visual studio 8\vc\include\functional(142) : while compiling class template member function 'bool std::less<_Ty>::operator ()(const _Ty &,const _Ty &) const'
with
[
_Ty=std::basic_string<char,std::char_traits<char>,std::allocator<char>>
]
c:\program files\microsoft visual studio 8\vc\include\queue(219) : see reference to class template instantiation 'std::less<_Ty>' being compiled
with
[
_Ty=std::basic_string<char,std::char_traits<char>,std::allocator<char>>
]
d:\projects\study\cpp\straus\containers2\containers2.cpp(116) : see reference to class template instantiation 'std::priority_queue<_Ty,_Container>' being compiled
with
[
_Ty=std::string,
_Container=std::deque<std::string>
]

При чем тут queue, это ж вроде priority_queue...
И еще 32 ошибки, вроде то же самое про stack, deque, vector, xtree...

Из них я понял только то, что что-то не в порядке с oparator()< для string. priority_queue его дергает, чтоб строку в нужное место вставить.
Закомментировал приведенный код, ошибки исчезли.
Добавил тупо сравнение через вышеуказанный оператор:

void testtest(){
    std::string str1("aaaa");
    std::string str2("bbbb");
    bool b = (str1 < str2);
}

Получил те же самые ошибки. Ну, не те же, тоже 33 штуки, только вида

error C2784: 'bool std::operator <(const std::queue<_Ty,_Container> &,const std::queue<_Ty,_Container> &)' : could not deduce template argument for 'const std::queue<_Ty,_Container> &' from 'std::string'
c:\program files\microsoft visual studio 8\vc\include\queue(103) : see declaration of 'std::operator <'

Перенес void testtest() в другой cpp-файл — все скомпилировалось.

Да, те контейнеры в output фигурируют видимо потому, что все они подключены в начале cpp-файла:

#include <iostream>
#include <map>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>

(Просто делаю примеры из Страуса, по очереди, ну и подключаю)

Есть идеи?

Что это за приём?

Fri, 05 Feb 2010 14:12:26 GMT

Какой смысл у такой записи:

    enum _Seekdir
        {    // constants for file positioning options
        _Seekmask = 0x3};
    static const _Seekdir beg = (_Seekdir)0;
    static const _Seekdir cur = (_Seekdir)1;
    static const _Seekdir end = (_Seekdir)2;

CppEvents

Fri, 05 Feb 2010 11:16:50 GMT

CppEvents — моя open-source либа, которая на днях была доведена до релиза, в связи с чем выносится на обсуждение. Либа предоставляет реализацию механизма событий/делегатов (сигналов/слотов) для C++. При разработке я ориентировался на аналогичные механизмы в C# и Qt, библиотеки Boost.Signals, LibSigC++ и SigSlot, и считаю что полученное решение превосходит остальные реализации.

Как и указанные библиотеки, моя основывается на шаблонах, но при этом точка зрения, с которой рассматривались события значительно отличается от других шаблонных реализаций, и лежит ближе к реализациям в C# и Qt. Я рассматривал событие не как самостоятельный объект, а в первую очередь как член класса, как средство представления в интерфейсе класса обратных сообщений, по аналогии с тем как функции-члены представляют прямые. Обработчиками событий также являются не объекты, а отдельные методы объектов (делегаты).

Как и в C#, события могут быть виртуальными и чисто виртуальными, могут использоваться в интерфейсах (мне этого ощутимо не хватало при работе с Qt).

Как и другие виды членов класса, события могут иметь уровень доступа. Но, в отличии от, скажем, функций-членов, события имеют два интерфейса — один для подключения обработчиков, другой для активации события. Моя реализация дает полный контроль над уровнями доступа. В C# — уровень доступа для интерфейса подключения задается явно, для интерфейса активации — всегда private, в Qt — всегда public/protected, в других шаблонных реализациях уровень доступа для интерфейсов не разделяется, что является грубым нарушением инкапсуляции. Таким образом, событие как сущность состоит из двух элементов — переменной-члена класса Cpp::Event<>, которая предоставляет интерфейс активации, и функции, которая возвращает временный объект класса Cpp::EventRef<>, который реализует интерфейс управления соединениями.

Я сознательно отказался от управления возвращаемыми значениями и выброшенными исключениями как от "идеологически вредных" фич — объект посылающий обратное сообщение по определению не должен ничего знать о количестве и характере его обработчиков, а потому обработать возвращенные значения и выброшенные исключения никак не может.

В минимальном объеме поддерживается параметризация делегатов — при соединении можно указать несколько значений, которые будут переданы в делегат как начальные аргументы. Как и в Qt последние аргументы события, которые "не влазят" в сигнатуру делегата, молча игнорируются. Также работает автоматическое преобразование типа аргументов события в типы аргументов делегата. Я не пытался реализовать возможности сравнимые с boost::bind, но постарался сделать синтаксис максимально удобочитабельным и лаконичным.

Реализовано автоматическое разъединение. В отличии от Boost.Signals и LibSigC++ оно работает всегда — написать код, который работает не так, как вы того ожидаете, намного сложнее. Автоматическое разъединение реализовано не в базовом классе, а во внешнем объекте — это дает большую гибкость в управлении соединениями и решает проблему запоздалого разъединения — если событие будет сгенерировано в процессе работы деструкторов промежуточных классов, то может быть вызван метод объекта, который уже не существует.

Библиотека является полностью потокобезопасной. Для обеспечения потокобезопасности используются атомарные счетчики и мьютексы. Для экономии ресурсов мьютексы создаются по одному на поток и разделяются между всеми объектами созданными в этом потоке (также сделано и в Qt). Указатель на мьютекс хранится в TLS. Абстракции синхронизационных примитивов реализованы для WinAPI и POSIX Threads + GCC intrinsics.

Мне удалось добиться очень эффективной реализации — по результатам замеров быстродействия мое детище работает в 6-8 раз быстрее Boost.Signals и в 1,5-2 раза быстрее Qt, так что реализацией внутренностей я весьма доволен, но вот над юзабилити еще собираюсь поработать — в частности, внешний connection scope сильно напрягает меня самого.

Библиотека хостится на гугл-коде — http://code.google.com/p/cpp-events. Дополнительную информацию, в частности tutorial с полу-реальными примерами, можно найти в wiki на сайте.

RTTI: Incomparable/Superclass/Subclass/Same

Thu, 04 Feb 2010 20:35:50 GMT

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

class Object
{
public:
  virtual ~Object(){};
};

enum Result
{
  Incomparable,
  Superclass,
  Subclass,
  Same
};

Result Compare(const Object& obj1, const Object& obj2)
{
  if(typeid(obj1) == typeid(obj2))
    return Same;
  ??? Что писать дальше?
}

Классы унаследованыые от Object изменять нельзя. В будущем возможно появятся новые классы унаследованные от Object. То есть желательно, чтобы функцию Compare было легко расширять.

Например, для классов

class A : public Object
{};
class B : public Object
{};
class AA : public A
{};

имеем

AA aa;
A a;
B b;
ASSERT( Subclass == Compare(aa, a);
ASSERT( Same == Compare(a, a);
ASSERT( Superclass == Compare(a, aa);
ASSERT( Incomparable == Compare(b, a);

совет

Thu, 04 Feb 2010 19:08:35 GMT

здравствуйте,

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

Function overloading in C

Thu, 04 Feb 2010 11:52:29 GMT

"Добрые" ребята из ISO C комитета решили использовать в интерфейсе библиотеки атомарных операций для С0х перегрузку функций.
А именно, имеется ряд функций вида:

C atomic_load_explicit(A*, memory_order);

где С и А могут быть:
short, atomic_short
unsigned short, atomic_ushort
int, atomic_int
unsigned, atomic_uint
long long, atomic_llong
unsigned long long, atomic_ullong
и т.д.

Что это смогут реализовать разработчики компиляторов, тем более будущих, сомнений нет (тем более, что уже есть прецедент перегрузки фукнций в С99 в <tgmath.h>). Я же хочу это реализовать для текущих компиляторов в виде библиотеки.
Для GCC есть возможность это реализовать с помощью __typeof__:

#define atomic_load_explicit(a, mo) ((__typeof__((a)->v))atomic_load_explicit_size((a), (mo), sizeof(*(a))))

inline unsigned long long atomic_load_explicit_size(a, mo, size)
{
    switch (size)
    {
    case 1: return atomic_load_explicit_1(a, mo);
    case 2: return atomic_load_explicit_2(a, mo);
    case 4: return atomic_load_explicit_4(a, mo);
    case 8: return atomic_load_explicit_8(a, mo);
    }
}

inline unsigned long long atomic_load_explicit_1(a, mo)
{
    switch (mo)
    {
    case memory_order_relaxed: return atomic_load_explicit_1_relaxed(a);
    case memory_order_consume: return atomic_load_explicit_1_consume(a);
    case memory_order_acquire: return atomic_load_explicit_1_acquire(a);
    case memory_order_release: return assert(0), 0;
    case memory_order_acq_rel: return assert(0), 0;
    case memory_order_seq_cst: return atomic_load_explicit_1_seq_cst(a);
    }
}

Однако я запнулся на том, как это реализовать для MSVC2005/2008 C. Есть какие-нибудь идеи?
Есть вариант просто убрать каст (__typeof__((a)->v)), и возвращать для всех вариантов unsigned long long. В целом это будет работать, но ОЧЕНЬ не нравится множество возникающих варнингов "conversion from 'unsigned __int64' to 'Х', possible loss of data".

Связь паралельных иерархий

Thu, 04 Feb 2010 09:42:00 GMT

Допустим есть иерархия контролов и отдельная иерархия состояний контролов

class ControlState
{};

class ButtonState: public ControlState
{};

class Control
{
  State* st;
};

class Button: public Control
{
  void SomeMethod()
  {
        ButtonState* but_state = dynamic_cast<ButtonState*>(st);//не нравится что постоянно приходится кастить!
        //...
  }
}

Дополнительное условие что все контролы могут хранится в каком-то контейнере, например vector<Control*>, поэтому должны наследоваться от общего класса.
Пока придумал следующие:

class Control
{
//Тут уже нет State
};

template<typename StateType>
class ControlWithState: public Control
{
    StateType st;;
}

class Button: public ControlWithState<ButtonState>
{
//Тут работаем с состоянием без кастов
}

Но в последнем варианте не нравится неинтуитивное наследование от ControlWithState, разроботчик который будет поддерживать код может сильно удивиться что в векторе хранятся Control* а наследуем мы от ControlWithState.
Кто что посоветует?
Спасибо.

... << RSDN@Home 1.2.0 alpha 4 rev. 1111>>

string literal conversion или unique id is returned back

Wed, 03 Feb 2010 21:31:53 GMT

Всем привет.

Есть некий символьный тип, размерность которого отлична от wchar_t и char_t. Хочется уметь присваивать ему строковые литералы, по аналогии с макросом _T или TEXT. Т.е. получить нечто вроде

const my_char *p = MY_TEXT("text"); // (1)
const my_char p1[] = MY_TEXT("text"); // (2)

Воспаленное сознание придумало пока что только следующий ход:

typedef wchar_t my_char;

template<size_t size, unsigned id>
struct MyLiteralBuffer
{
static my_char Data[size];
};

template<size_t size, unsigned id>
my_char MyLiteralBuffer<size, id>::Data[size];

template<size_t size>
const my_char (&MyConvert(const char (&src)[size], my_char (&dst)[size]))[size]
{
// literal conversion here
  return dst;
}

#define MY_TEXT(str) MyConvert(str, MyLiteralBuffer<sizeof(str), __COUNTER__>::Data)

С этим кодом есть как минимум 2 проблемы:
1. использование макроса __COUNTER__ — его нет на стареньких gcc, а именно они и есть целевая платформа, да и в целом он не гарантирует уникальности статического буфера.
2. не работает вариант использования (2).

Соответственно, вопросы.
1. Есть ли более-менее портабельный в рамках gcc для организации компайл-тайм счетчика?
2. Есть ли вообще возможность заставить работать вариант (2)?
3. Может, есть более другие варианты добиться желаемого? Не использовать свои типы не предлагать

Спасибо!

std::set memcpy

Wed, 03 Feb 2010 18:57:55 GMT

можно ли как-нибудь все-таки засунуть std::set в memcpy ? да, я понимаю, но вот пример

есть функция, которой сто лет в обед

void App::swap(Base * this_b, Base * that_b)
{
unsigned int size = thisent->size();
...
memcpy( (char *)thisent, (char *)thatent, size); /// больное место
...
}

класс Base — это корешок развесистого дерева и через сто лет обнаружили что в одном из Derived есть std::set.
после App::swap этот std::set рассыпается.

вопрос:
как наименьшими затратами обойти проблему ?

1. добавить всем Derived приличный swap — очень затратно
2. сделать темплейт из App:swap и написать спец версию для Derived — а вдруг потом кто-то напишет еще Derived с set ? можно это избежать ?
3. заменить set на что-то почти такое же, но безопасное для memcpy ? vector + std::unique

спасибо!

shared_ptr

Wed, 03 Feb 2010 11:58:39 GMT

В описании shared_ptr приведен пример использования.

template<class T> class pointer
{
    T * p_;
public:
    explicit pointer(T * p): p_(p)
    {
    }

    boost::shared_ptr<T> operator->() const
    {
        p_->prefix();
        return boost::shared_ptr<T>(p_, std::tr1::mem_fn(&T::suffix));
    }
};

class X
{
private:
    void prefix() {}
    void suffix() {}
    friend class pointer<X>;  
public:
    void f() {}
    void g() {}
};

int _tmain(int argc, _TCHAR* argv[])
{
    X x;
    pointer<X> px(&x);

    px->f(); //***
    px->g();

    return 0;
}

Вопрос вызывает вызов, отмеченный ***, для которого MSVC2008 сделал код

    px->f();
004115D9  lea         eax,[ebp-100h] 
004115DF  push        eax  
004115E0  lea         ecx,[ebp-20h] 
004115E3  call        pointer<X>::operator-> (411050h) 
004115E8  mov         dword ptr [ebp-108h],eax 
004115EE  mov         ecx,dword ptr [ebp-108h] 
004115F4  mov         dword ptr [ebp-10Ch],ecx 
004115FA  mov         dword ptr [ebp-4],0 
00411601  mov         ecx,dword ptr [ebp-10Ch] 
00411607  call        boost::shared_ptr<X>::operator-> (411203h) //???????
0041160C  mov         ecx,eax 
0041160E  call        X::f (411032h) 
00411613  mov         dword ptr [ebp-4],0FFFFFFFFh 
0041161A  lea         ecx,[ebp-100h] 
00411620  call        boost::shared_ptr<X>::~shared_ptr<X> (411249h)

Собственно я не пойму откуда взялось второе разыменование, которое помечено "???????". Первое разыменование мы вызвали сами как часть выражения "px->" (и оно вернуло нам тип boost::shared_ptr<X>), а вот откуда второе? Его-то кто звал?

Вызов конструкторов

Wed, 03 Feb 2010 07:48:08 GMT

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

#include <iostream>

template<class T>
struct A
{
    A() { std::cout << "A()" << std::endl; }
    A(A const& a) { std::cout << "A(A const&)" << std::endl; }
    A(T x) { std::cout << "A(T)" << std::endl; }
    void fff() {}    
};

int main()
{    
    typedef A<int> my_a;
    int x = 1;
    
    {
        &my_a(x);
        std::cout << "-----" << std::endl;
    }    

    {    
        my_a(x);
        std::cout << "-----" << std::endl;
    }

    {    
        my_a(x).fff();
        std::cout << "-----" << std::endl;
    }

    {
        &my_a(x);
        my_a(x);
        std::cout << "-----" << std::endl;
    }

    {    
        my_a(x);
        my_a(x).fff();
        std::cout << "-----" << std::endl;
    }

    {
        &my_a(x);
        my_a(x).fff();
        std::cout << "-----" << std::endl;
    }

    {
        &my_a(x);
        my_a(x);
        my_a(x).fff();
        std::cout << "-----" << std::endl;
    }

    char c;
    std::cin >> c;
}

Конструируется-разрушается N объектов типа A<int>. Конструируются всегда одинаково — через A<int>::A(int). Наивно предполагаем, что при запуске программа выведет N раз строчку "A(T)". Фактически же получается так:

A(T) — понятно // 1
-----
A() — не понятно // 2
-----
A(T) — понятно // 3
-----
A(T) — понятно // 4
A() — не понятно
-----
A() — не понятно // 5
A(A const&) — вообще не понятно
-----
A(T) — понятно // 6
A(T) — понятно
-----
A(T) — понятно // 7
A() — не понятно
A(A const&) — вообще не понятно
-----

Подскажите почему так происходит. Особенно убивает 5-ая группа (то же самое и в 7-ой): ожидается то же самое, что и в 2 + 3 (1 + 2 + 3 в 7-ой).

Спасибо.