Need Help... Writing on to, Scanning, and Returning Data from .txt File?

[MattTuck]

Question:
So I want to send and store: words, their definition, synonyms, and part of speech, in a .txt file and later be able to recall and use the words according to their part of speech(and posibly have a synonym picked at random to replace it) ...how might I do that? Examples would help me a ton!

[MattTuck]

Bump

[SamuelAdams]

Do you have a Dict file in mind that you plan to use or you want to make one ?

First you need to come up with a format for your text file.

[MattTuck]

The plan was to make one. It hadn't occured to me that I might be able to find one pre made, though now that it's been pointed out as an option, I'd rather find one if possible.

And as far as format, my thought was something along the lines of:
Word 'tab' Parts of speech 'tab' synonyms 'tab' definition

The idea is for part of a chatbot. I want to be able to scan the file for the word, find the part of speech it belongs to and respond accordingly, and to randomly switch out the word for one of its synonyms.

[MattTuck]

It's my assuption that I need to write something like:

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  char str[] =userResponse;
  char * pch;
  pch = strtok (userResponse," ");
  ofstream myfile ("dic.txt");
  if (myfile.is_open())
  {
    myfile << strtok

But I'm not sure how to keep it in the format that I want.

Sorry if I butchered the code, I'm still fairly new to C++ and coding as a whole.

[MattTuck]

Bump

[JLBorges]

> It's my assuption that I need to write something like:

> #include <stdio.h>
> // ...
>   char str[] =userResponse;
>   char * pch;
>   pch = strtok (userResponse," ");
> // ... 

You would discover that learning to use the standard C++ library makes programming a lot easier.
The task is certainly not trivial, but with standard C++, it becomes an order of magnitude simpler.

For instance:

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <iterator>
#include <map>
#include <fstream>

// define a class to hold the information
struct word_info
{
    enum part_of_speech_t { NOUN, PRONOUN,  ADJECTIVE, DETERMINANT,
                             VERB, ADVERB, PREPOSITION, CONJUNCTION, UNKNOWN };
    part_of_speech_t part_of_speech ;
    std::vector<std::string> synonyms ; // www.mochima.com/tutorials/vectors.html
    std::string definition ;
};

constexpr char TAB = '\t' ; // http://www.stroustrup.com/C++11FAQ.html#constexpr
constexpr char SPACE = ' ' ;
constexpr char NEWLINE = '\n' ;

// provide a function to write the information into a stream
std::ostream& operator<< ( std::ostream& stm, const word_info& info )
{
    // wrie part_of_speech, TAB
    stm << info.part_of_speech << TAB ;

    // write synonyms, TAB
    // http://www.stroustrup.com/C++11FAQ.html#for
    for( const std::string& synonym : info.synonyms ) stm << synonym << SPACE ;
    stm << TAB ;

    // write definition, NEWLINE
    return stm << info.definition << NEWLINE ;
}

// provide a function to read the information from a stream
std::istream& operator>> ( std::istream& stm, word_info& info )
{
    // read part_of_speech
    int pos ;
    stm >> pos ;
    if( pos >= word_info::NOUN && pos < word_info::UNKNOWN )
        info.part_of_speech = word_info::part_of_speech_t(pos) ;
    else info.part_of_speech = word_info::UNKNOWN ;

    // http://www.cplusplus.com/reference/istream/istream/ignore/
    stm.ignore( 1000, TAB ) ; // throw away the TAB after part of speech

    // read synonyms, upto the next TAB
    std::string synonyms ;

    // http://www.cplusplus.com/reference/string/string/getline/
    std::getline( stm, synonyms, TAB ) ;

    // http://www.cplusplus.com/reference/sstream/istringstream/
    std::istringstream str_stream(synonyms) ;

    // http://www.cplusplus.com/reference/iterator/istream_iterator/
    std::istream_iterator<std::string> begin(str_stream), end ;

    // http://www.stroustrup.com/C++11FAQ.html#uniform-init
    info.synonyms = { begin, end } ;

    // read definition, everything left up to the NEWLINE
    return std::getline( stm, info.definition, NEWLINE ) ;
}

// defie a dictionary type to associate a word with its word_info
// http://www.cplusplus.com/reference/map/map/
// http://www.stroustrup.com/C++11FAQ.html#template-alias
using dictionary_type = std::map< std::string, word_info > ;

// provide a function to look up the dictionar for synonyms
std::vector<std::string> synonyms( const std::string& word, const dictionary_type& dict )
{
   auto iter = dict.find(word) ;
   return iter != dict.end() ? iter->second.synonyms : std::vector<std::string>{} ;
}

// TODO: provide a function to look up the dictionar for part_of_speech
word_info::part_of_speech_t pos( const std::string& word, const dictionary_type& dict ) ;

// TODO: provide a function to look up the dictionar for definition
std::string definition( const std::string& word, const dictionary_type& dict ) ;


// now, put it all together
int main()
{
    // create a dictionary mapping word toword_info
    dictionary_type dictionary // http://www.stroustrup.com/C++11FAQ.html#uniform-init
    {
        {
            "synonym",
            {
                word_info::NOUN,
                { "metonym", "equivalent", "analogue" },
                "word having or nearly the same meaning as another"
            }
        },
        {
            "colourful",
            {
                word_info::ADJECTIVE,
                { "hued", "vivid", "florid", "prismatic" },
                "richly or strikingly coloured"
            }
        },
        {
            "disembark",
            {
                word_info::VERB,
                { "alight", "dismount" },
                "get off a car, train, plane, ship etc."
            }
        }
        // etc.
    };

    // write the contents to a file
    const char* const file_name = "dict.txt" ;
    {
        std::ofstream file(file_name) ;
        for( const auto& pair : dictionary )
            file << pair.first << TAB << pair.second << NEWLINE ;
    }

    dictionary.clear() ; // empty the dictionary

    // read the contents back from the file
    {
        std::ifstream file(file_name) ;
        std::string word ;
        word_info info ;
        while( std::getline( file >> std::ws, word, TAB ) && file >> info )
            dictionary.emplace( word, info ) ;
    }

    // add two americanglish synonyms for disembark
    const std::string disembark = "disembark" ;
    dictionary[disembark].synonyms.push_back( "deplane" ) ;
    dictionary[disembark].synonyms.push_back( "detrain" ) ;

    // lookup and print synonyms for "disembark"
    std::cout << "synonyms for " << disembark << ": " ;
    for( const std::string& synonym : synonyms( disembark, dictionary ) )
        std::cout << synonym << SPACE ;
    std::cout << NEWLINE ;
}

http://coliru.stacked-crooked.com/a/ad47cf1034950585