Re: Static struct array or array of array

On Fri, 13 Apr 2007 09:32:27 +0200, mosfet <john.doe@anonymous.org>
wrote:


(Even if it is not very MFC related.... :)

I think that your approach of using raw C array and raw C (char *)
strings is very old and obsolete (Joe would tell us: "Something like
the punch-cards!" :)

We are in the C++ (and even managed code! :) era.
So, if you are not developing an operating system kernel or device
driver, you should consider C++ with OO and not raw C.

I believe you should do a more object-oriented C++ approach, that will
give you a more robust, readable and extensible code.

Below you can find some code that seems to work.
There is a class called StringList which is a thin wrapper over
std::vector< std::string >.

And there is the FileExtensionChecker class (that uses the StringList)
and exposes the method "IsAValidFile" as you described in your post.
You can use that class as following:

 FileExtensionChecker extChecker;
 extChecker.IsAValidFile( "gif", FileExtensionChecker::ePhoto );
 extChecker.IsAValidFile( "mid", FileExtensionChecker::eMusic );

Note that you have just two kind of file types (photo and music); so I
used simple if's in the implementation. But if you have more file
types, you may consider implementing a more advanced and scalable
solution using std::map to create a map between the kind of file
(photo, music, ...) and the StringList of valid extensions:

  map: KindOfFile --> ExtensionsStringList

HTH:

<CODE>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // find

// Containers for some strings
class StringList
{
public:

    StringList();

    // Add a new string to the container
    StringList & StringList::Add( const std::string & s );

    // Remove all strings
    void StringList::Clear();

    // Number of strings
    size_t StringList::Count() const;

    // Is the input string stored into the container?
    bool StringList::Contains( const std::string & s ) const;

private:

    // Implement using std::vector
    typedef std::vector< std::string > StringListT;
    StringListT m_strings;

};

inline StringList & StringList::Add( const std::string & s )
{
    m_strings.push_back( s );
    return *this;
}

inline void StringList::Clear()
{
    m_strings.clear();
}

inline size_t StringList::Count() const
{
    return m_strings.size();
}

StringList::StringList()
{
    // Nothing to do
}

bool StringList::Contains( const std::string & s ) const
{
    if ( m_strings.empty() )
        return false;

    if ( std::find(
        m_strings.begin(),
        m_strings.end(),
        s
        ) == m_strings.end() )
    {
        return false;
    }

    return true;
}

//////////////////////////////////////////////////////////////////////////

class FileExtensionChecker
{
public:

    enum EFileType
    {
        ePhoto = 0,
        eMusic
    };

    FileExtensionChecker();

    bool IsAValidFile( const std::string & fileExtension,
                       EFileType fileType ) const;

private:
    StringList m_photoExtensions;
    StringList m_musicExtensions;

    void Init();
};

FileExtensionChecker::FileExtensionChecker()
{
    Init();
}

void FileExtensionChecker::Init()
{
    m_photoExtensions.Clear();
    m_photoExtensions.Add("jpg").Add("jpeg").Add("gif");
    m_photoExtensions.Add("bmp").Add("png");

    m_musicExtensions.Clear();
    m_musicExtensions.Add("mp3").Add("aiff").Add("mid").Add("wav");
}

bool FileExtensionChecker::IsAValidFile(
        const std::string & fileExtension,
        EFileType fileType ) const
{
    if ( fileType == ePhoto )
        return m_photoExtensions.Contains( fileExtension );
    else if ( fileType == eMusic )
        return m_musicExtensions.Contains( fileExtension );
    else
        return false;
}

</CODE>

MrAsm