Error c2440 function style cast

Одной из самых распространенных ошибок, с которыми сталкивается программист при переносе приложений с Win32 на Win64 систему, является ошибка, связанная с использованием функции OnTimer. Функции OnTimer используется практически в каждом приложении и высока вероятность, что вы получите несколько ошибок компиляции. Ранее (в Visual Studio 6) эта функция имела прототип «OnTimer(UINT nIDEvent)» и скорее всего так же представлена в пользовательских классах. Сейчас эта функция имеет прототип «OnTimer(UINT_PTR nIDEvent)», что приводит к ошибке компиляции для 64-битной системы.

Рассмотрим стандартный пример:

class CPortScanDlg : public CDialog
{
  ...
  afx_msg void OnTimer(UINT nIDEvent);
  ...
};
BEGIN_MESSAGE_MAP(CPortScanDlg, CDialog)
...
  ON_WM_TIMER()
END_MESSAGE_MAP()

Для данного кода на этапе компиляции будет выдана следующая ошибка:

1>.SrcPortscandlg.cpp(136) : error C2440: 'static_cast' :
cannot convert from 'void (__cdecl CPortScanDlg::* )(UINT)' to
'void (__cdecl CWnd::* )(UINT_PTR)'
1> Cast from base to derived requires dynamic_cast or static_cast

Дело в том, что в макросе ON_WM_TIMER происходит явное приведение типа функции:

#define ON_WM_TIMER() 
{ WM_TIMER, 0, 0, 0, AfxSig_vw, 
  (AFX_PMSG)(AFX_PMSGW) 
  (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT_PTR) > 
    ( &ThisClass :: OnTimer)) },

Приведение успешно выполняется при сборке 32-битной версии, так как типы UINT и UINT_PTR совпадают. В 64-битном режиме это различные типы и приведение типа функции невозможно, отчего и возникает на первый взгляд не очень понятная ошибка компиляции.

Исправить данную ошибку достаточно просто. Необходимо изменить объявление функции OnTimer в пользовательских классах. Пример исправленного кода:

class CPortScanDlg : public CDialog
{
  ...
  afx_msg void OnTimer(UINT_PTR nIDEvent); //Fixed
  ...
};

Иногда в программах функция OnTimer используется неоднократно.

Можно порекомендовать сразу поискать строчку «OnTimer(UINT » и заменить ее на «OnTimer(UINT_PTR «. Также можно воспользоваться множественной заменой, как показано на рисунке 1.

Рисунок 1 — Использование функции «Find and Replace» для исправления объявления функций OnTimer

Не забудьте только, что в обоих случаях в конце строк должен стоять пробел. Этот пробел, к сожалению, не виден на рисунке. Если пробелов не будет, то у вас может получиться «OnTimer(UINT_UINT_PTR nIDEvent)».

Я пытаюсь создать итератор для реализации связанных списков. Но я получаю сообщение об ошибке. Моя реализация ниже:

#ifndef LinkedListIterative_h
#define LinkedListIterative_h

#include <cstdio>

using std::swap;

template <typename T>
class LinkedList;

template <typename T>
class Iterator;

template<typename T>
class Node
{
    private:
        friend class Iterator<T>;
        friend class LinkedList<T>;        

        T data;
        Node *next;

        Node() : next(nullptr) {}
        Node(const T& data) : data(data) {}
};

template<typename T>
class Iterator
{
    private:
        Node<T> *node;

    public:
        Iterator() : node(nullptr) {}

        Iterator(Node<T> *node) : node(node)  {}

        Iterator(const Node<T> *node) : node(node)  {}

        Iterator(const Iterator& iterator) : node(iterator.node)
        {

        }

        Iterator& operator= (const Iterator& rhs)
        {
            if( this != &rhs )
            {
                node = rhs.node;
            }
        }

        Iterator& operator++()
        {
            node = node->next;

            return *this;
        }

        Iterator& operator+(size_t index)
        {
            while( index-- > 0 && (node != nullptr) )
            {
                ++this;
            }

            return *this;
        }

        Iterator& operator[](size_t index)
        {
            while( index-- > 0 && (node != nullptr) )
            {
                ++this;
            }

            return *this;
        }

        bool operator==(const Iterator &iter)
        {
            return node == iter.node;
        }

        bool operator!=(const Iterator &iter)
        {
            return node != iter.node;
        }

        T& operator*() { return node->data; }

};

template <typename T>
class LinkedList
{
    private:
        size_t size;
        Node<T> *first;
        Node<T> *last;

        Node<T>* createNode(const T &item)
        {
            Node<T> *node = new Node<T>;

            node->data = item;
            node->next = nullptr;

            return node;
        }

        LinkedList(const LinkedList& list){}

        LinkedList& operator=(const LinkedList& list){}

    public:
        typedef Iterator<T> iterator;
        typedef Iterator<const T> const_iterator;

        LinkedList() : size(0), first(nullptr), last(nullptr)
        {

        }

        // Add item at the end of the list
        void add(const T& item)
        {
            Node<T> *node = createNode(item);

            if(first == nullptr)
            {
                first = node;
                last  = node;
            }
            else
            {
                last->next = node;
                last = node;
            }

            ++size;
        }

        void add(const T& item,size_t index)
        {
            if( size == 0 )
            {
                add(item);
            }
            else if( index == 0 && size > 0 )
            {
                addToFirst(item);
            }
            else if( index >= size )
            {
                addToLast(item);
            }
            else
            {
                Node<T> *prev = first;
                Node<T> *curr = first;

                int i = 0;

                while( i++ < index  )
                {
                    prev = curr;
                    curr = curr->next;
                }

                Node<T> *node = createNode(item);

                prev->next = node;
                node->next = curr;

                ++size;
            }
        }

        void addToFirst(const T& item)
        {
            Node<T> *node = createNode(item);

            node->next = first;

            first = node;

            if(size == 0)
                last = node;

            ++size;
        }

        void addToLast(const T& item)
        {
            Node<T> *node = createNode(item);

            last->next = node;

            last = node;

            if(size == 0)
                first = node;

            ++size;
        }

        void removeFirst()
        {
            if( first == nullptr )
                return;

            Node<T> *temp = first;

            first = first->next;

            --size;

            delete temp;

            if( size == 0 )
                last = first;
        }

        void remove(const size_t index)
        {
            if( size == 0 || index > size - 1 )
                throw std::out_of_range("Out of range");

            if(index == 0)
            {
                removeFirst();
                return;
            }

            Node<T> *curr = first;
            Node<T> *prev = first;

            size_t i(0);

            while( i++ < index )
            {
                prev = curr;
                curr = curr->next;
            }

            if( curr == last )
            {
                last = prev;
            }

            prev->next = curr->next;

            delete curr;

            --size;
        }

        void removeLast()
        {
            if( first == nullptr )
                return;

            Node<T> *curr = first;
            Node<T> *prev = first;

            while( curr != last )
            {
                prev = curr;
                curr = curr->next;
            }

            prev->next = nullptr;

            delete last;

            last = prev;

            --size;

            if( size == 0 )
                first = last;
        }

        T& getItem(size_t index) const
        {
            if(index > size)
                throw std::out_of_range("index out of bound!");

            Node<T> *curr = first;

            size_t i = 0;

            while ( i++ != index )
                curr = curr->next;

            return curr->data;
        }

        size_t length() const
        {
            return size;
        }

        iterator begin()
        {
            return iterator(first);
        }

        iterator end()
        {
            return iterator(last); //getting error here
        }

        const_iterator begin() const
        {
            return const_iterator(first);
        }

        const_iterator end() const
        {
            const_iterator(last);
        }

        ~LinkedList()
        {
            Node<T> *curr = first;

            while( curr != last )
            {
                Node<T> *temp = curr;

                curr = curr->next;

                delete temp;
            }
        }           
};


#endif /* LinkedListIterative_h */

Ошибка, которую я получаю:

Error C2440 '<function-style-cast>': cannot convert from 'Node<T> *const ' to 'Iterator<const T>'   

Вызывающий этого внутреннего элемента:

void printList(const LinkedList<int>& list)
{
    size_t index = 0;

    LinkedList<int>::const_iterator iter = list.begin();

    for(; iter != list.end(); ++iter)
    {
        std::cout << *iter << " ";
    }

    while( index < list.length() )
    {
        std::cout << list.getItem(index ++) << " ";
    }

    std::cout << std::endl;
}

Я не могу понять, что случилось.

Here is a template class that enables writing and reading enum class members as strings. It is a simplification of Loki Astari’s design. It avoids the need for helper functions, as suggested by Veski, by using the enable_if<> and is_enum<> templates.

The idea is to replace template <T> with

template <typename T,
    typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>

The consequence is that the operator<<() and operator>>() templates are only instantiated for enums (because of the Substitution Failure Is Not An Error (SFINAE) principle). Then the helper classes enumConstRefHolder and enumRefHolder, and the functions enumToString() and enumFromString(), are no longer needed.

In addition to recognizing an enum member by a string (normalized to be all capital letters), the code recognizes its integer representation. (For the example below, both "FaST" and "1" will be read as Family::FAST.)

EnumIO.h:

#ifndef ENUMIO_H_
#define ENUMIO_H_

#include <algorithm>
#include <ios>
#include <iostream>
#include <sstream>
#include <vector>

// A template class that enables writing and reading enum class
// members as strings.
//
// Author:  Bradley Plohr (2017-05-12)
//
// Note:  The idea to keep the enum names as a static member in a
// template comes from Loki Astari:
//
// https://codereview.stackexchange.com/questions/14309
//         /conversion-between-enum-and-string-in-c-class-header
//
// Usage example:
//
// Enums.h:
// -------
// #ifndef ENUMS_H_
// #define ENUMS_H_
//
// enum class Family { SLOW, FAST };
//
// TODO:  other enum classes
//
// #endif /* ENUMS_H_ */
//
//
// Enums.cc:
// --------
// #include "Enums.h"
// #include "EnumIO.h"
// #include <string>
// #include <vector>
//
// template <>
// const std::vector<std::string>& EnumIO<Family>::enum_names()
// {
//      static std::vector<std::string> enum_names_({ "SLOW", "FAST" });
//      return enum_names_;
// }
//
// TODO:  enum names for other enum classes
//
//
// t_EnumIO.cc:
// -----------
// #include "EnumIO.h"
// #include "Enums.h"
// #include <iostream>
//
// int
// main()
// {
//     Family family;
//
//     family = Family::SLOW;
//     std::cout << family << std::endl;
//
//     std::cin >> family;
//     std::cout << family << std::endl;
//
//     return 0;
// }
//
// For the input
//
//     fAsT
//
// the output is
//
//     SLOW
//     FAST

template <typename T>
class EnumIO
{
public:
    static const std::vector<std::string>& enum_names();
};

template <typename T,
        typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
std::ostream&
operator<<(std::ostream& os, const T& t)
{
    os << EnumIO<T>::enum_names().at(static_cast<int>(t));

    return os;
}

static std::string
toUpper(const std::string& input)
{
    std::string copy(input);
    std::transform(copy.cbegin(), copy.cend(), copy.begin(),
            [](const unsigned char i) { return std::toupper(i); });

    return copy;
}

template <typename T,
        typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
std::istream&
operator>>(std::istream& is, T& t)
{
    std::string input;
    is >> input;
    if (is.fail())
        return is;
    input = toUpper(input);

    // check for a match with a name
    int i = 0;
    for (auto name : EnumIO<T>::enum_names()) {
        if (toUpper(name) == input) {
            // Here we assume that the integer representation of
            // the enum class is the default.  If the enum class
            // members are assigned other integers, this code
            // must be extended by consulting a vector containing
            // the assigned integers.
            t = static_cast<T>(i);

            return is;
        }
        ++i;
    }

    // check for a match with an integer
    int n = static_cast<int>(EnumIO<T>::enum_names().size());
    std::istringstream iss(input);
    int value;
    iss >> value;
    if (not iss.fail() && 0 <= value && value < n) {
        t = static_cast<T>(value); // See the comment above.
        return is;
    }

    is.setstate(std::ios::failbit);

    return is;
}

#endif /* ENUMIO_H_ */