Как избежать частой ошибки в большой кодовой базе?

1) Создайте собственный строковый класс, который наследует / содержит std::string.

2) В этом классе перегрузите operator+=(int val) и сделайте его закрытым.

3) Используйте этот класс для всех ваших строковых операций.

Это приведет к ошибкам флага компилятора всякий раз, когда вы сделаете что-то вроде этого:

MyString str;
str += 27;

Вы не можете отключить определенную функцию класса (здесь std :: basic_string), поскольку это интерфейс, который явно (и официально) разрешает эту манипуляцию. Попытка перегрузить оператора только испортит ситуацию.

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

Я рекомендую сначала заменить строковые типы на typedef:

namespace myapp
{
    typedef std::string String;
    typedef std::wstring UTFString;
}

Затем, когда ваше приложение компилируется нормально после замены std :: string и std :: wstring на myapp :: String и myapp :: UTFString (это примеры имен), вы определяете класс-оболочку где-нибудь:

namespace myapp
{
/** std::basic_string with limited and controlled interface.
    */
    template< class _Elem, class _Traits, class _Ax >
    class limited_string 
    {
    public:
        typedef std::basic_string< _Elem , _Traits, _Ax > _String; // this is for easier writing
        typedef limited_string< _Elem, _Traits, _Ax > _MyType; // this is for easier writing

    private:
        _String m_string; // here the real std::basic_string object that will do all the real work!

    public:

        // constructor proxies... (note that those ones are not complete, it should be exactly the same as the original std::basic_string
        // see some STL docs to get the real interface to rewrite)
        limited_string() : m_string {}
        limited_string( const _MyType& l_string ) : m_string( l_string.m_string ) {}
        limited_string( const _Elem* raw_string ) : m_string( raw_string ) {}
        //... etc...

        // operator proxies...
        _MyType& operator= ( const _MyType& l_string ) 
        {
            m_string = l_string.m_string;
        }
        // etc...
        // but we don't want the operator += with int values so we DON'T WRITE IT!

        // other function proxies...
        size_t size() const { return m_string.size(); } // simply forward the call to the real string!
        // etc...you know what i mean...

        // to work automatically with other STL algorithm and functions we add automatic conversion functions:
        operator const _Elem*() const { return m_string.c_str(); } 

        // etc..        


    };
}

... затем вы просто заменяете эти строки:

// instead of those lines...
    //typedef std::string String; 
    //typedef std::wstring UTFString;

    // use those ones
    typedef limited_string< char, std::char_traits<char>, std::allocator<char> >                String; // like std::string typedef
    typedef limited_string< wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >       UTFString; // like std::wstring typedef 

... и ваш пример выйдет из строя:

error C2676: binary '+=' : 'myapp::UTFString' does not define this operator or a conversion to a type acceptable to the predefined operator
error C2676: binary '+=' : 'myapp::String' does not define this operator or a conversion to a type acceptable to the predefined operator

Вот полный код тестового приложения, который я написал, чтобы доказать это (скомпилирован на vc9):

#include <string>
#include <iostream>

namespace myapp
{

    /** std::basic_string with limited and controlled interface.
    */
    template< class _Elem, class _Traits, class _Ax >
    class limited_string 
    {
    public:
        typedef std::basic_string< _Elem , _Traits, _Ax > _String; // this is for easier writing
        typedef limited_string< _Elem, _Traits, _Ax > _MyType; // this is for easier writing

    private:
        _String m_string; // here the real std::basic_string object that will do all the real work!

    public:

        // constructor proxies... (note that those ones are not complete, it should be exactly the same as the original std::basic_string
        // see some STL docs to get the real interface to rewrite)
        limited_string() : m_string {}
        limited_string( const _MyType& l_string ) : m_string( l_string.m_string ) {}
        limited_string( const _Elem* raw_string ) : m_string( raw_string ) {}
        //... etc...

        // operator proxies...
        _MyType& operator= ( const _MyType& l_string ) 
        {
            m_string = l_string.m_string;
        }
        // etc...
        // but we don't want the operator += with int values so we DON'T WRITE IT!

        // other function proxies...
        size_t size() const { return m_string.size(); } // simply forward the call to the real string!
        // etc...you know what i mean...

        // to work automatically with other STL algorithm and functions we add automatic conversion functions:
        operator const _Elem*() const { return m_string.c_str(); } 

        // etc..        


    };

    // instead of those lines...
    //typedef std::string String; 
    //typedef std::wstring UTFString;

    // use those ones
    typedef limited_string< char, std::char_traits<char>, std::allocator<char> >                String; // like std::string typedef
    typedef limited_string< wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >       UTFString; // like std::wstring typedef 
}

int main()
{
    using namespace myapp;

    int age = 27;

    UTFString str = UTFString(L"User's age is: ");
    str += age; // compilation error!
    std::wcout << str << std::endl;

    String str2 = String("User's age is: ");
    str2 += age; // compilation error!
    std::cout << str2 << std::endl;

    std::cin.ignore();

    return 0;
}

Я думаю, это решит вашу проблему, но вам придется обернуть все функции.

Большинство систем управления версиями позволяют выполнять проверки работоспособности вашего кода во время проверки. Таким образом, вы можете настроить тест, который выполняет проверку и отклоняет проверку в случае сбоя:

Пример:

Тестовый сценарий:

#!/bin/tcsh
# Pass the file to test as the first argument.

echo "#include <string>\
void operator+=(std::string const& , int const&);\
void operator+=(std::string const& , int);"\
| cat - $1 \
| g++ -c -x c++ -  >& /dev/null


echo $status

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

NB: оператор + = идея украдена из литб. Кто с тех пор удалил свой пример. Но кредит там, где это было необходимо.

Нет простого способа предотвратить это, но есть простой способ его найти. Напишите небольшую программу, которая использует этот оператор, а затем посмотрите на искаженный символ оператора + =, который вы хотите запретить. Этот символ представляет собой уникальную строку. В рамках автоматизированных тестов используйте DUMPBIN (или аналогичный инструмент для Linux / Mac), чтобы проверить, присутствует ли этот искаженный символ в ваших объектных файлах.