Programming

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define CHUNK 4096
#define TOKEN " \r\n\t" // Includes newlines and \r since fgets includes them

int main(int argc, char *argv[])
{
        int bufsize=CHUNK;
        // Flag variable.  First loop it holds nothing, all other loops,
        // holds "\n" to print a newline before >...
        char *prefix="";
        // Start with a CHUNK-sized buffer that can be enlarged at need
        char *buf=malloc(bufsize);
        FILE *fp;

        if(argc != 2) {
                fprintf(stderr, "No file given\n");
                exit(1);
        }

        fp=fopen(argv[1], "r");
        if(fp == NULL)
        {
                fprintf(stderr, "Can't open %s\n", argv[1]);
                return(1);
        }

        while(fgets(buf, bufsize, fp) != NULL)
        {
                char *tok;
                size_t len=strlen(buf);
                // Increase buffer size if fgets didn't get a complete line
                // complete, as in, ends in '\n'
                while(  buf[len-1] != '\n')
                {
                        buf=realloc(buf, bufsize+=CHUNK); // Make buffer bigger
                        // Read the rest of the line
                        if(fgets(buf+len, CHUNK, fp) == NULL) break;
                        // Count the new length
                        len+=strlen(buf+len);
                }

                tok=strtok(buf, TOKEN);
                if(tok == NULL) // Something strange happened -- no line?
                        continue;

                while(tok != NULL)
                {
                        if(tok[0] == '>')
                        {
                                printf("%s%s ", prefix, strtok(buf, TOKEN));
                                prefix="\n";
                                break; // Leave the loop to ignore all other tokens on this line
                        }
                        fputs(tok,stdout);
                        tok=strtok(NULL, TOKEN);
                }
        }

        fputc('\n', stdout);
        fclose(fp);
}

#include <iostream>
#include <fstream>
#include <string>
#include <map>

/**
 * You need string.h for strtok and strcpy.  MANDATORY!
 * Not having the right headers can cause a CRASH!
 */
#include <string.h>

using namespace std;

int main()
{
   ifstream inFILE("infile.fasta");
   /* You're not using this */
   //int inGuard = 1;               //using a guard variable

   /**
    * If you put it inside the loop, it goes out of scope every loop.
    * That's good when you want that, and bad when you don't.
    * Since you want the value to stay the same every loop, you don't.
    */
   string entryID;

   map <string, string>FastaSeq;   //Declare a map to hold each sequence entry

   while (inFILE.good()) {
      string line;        //declare string for each line
      /* moved above */
      //string entryID, sequence;    //declare two strings for key and value for map
      char *sPtr;        //Declare char pointer sPtr for tokens
      getline(inFILE, line);    //Read the whole line

      //Initialize char pointer sArray for conversion of the string to char*    
      char *sArray = new char[line.length() + 1];
      strcpy(sArray, line.c_str());

      if (sArray[0] == '>') {
         sPtr = strtok(sArray, " ");    //Using space as delimiter get the first token.
         /**
          * If your program crashes, odds are you won't see anything printed to cout.
          * use cerr for debugging instead, it prints instantly instead of being held for later.
          *
          * Use cerr for errors/debugging, cout for data output.
          */
         //cout << sPtr << " ";       //Print the first token only
         cerr << endl << sPtr << " ";
         entryID = sPtr;             //assign the first token as key for the map
         continue;
     } else  {
         sPtr = strtok(sArray, " ");    //Get all the tokens with " " as delimiter.

         /**
          * Always, always, always check your pointers!
          * Never assume strtok must have worked.
          * This is what broke your last 3 programs.
          */
         //FastaSeq[entryID] += sPtr;   // assign first part of sequence to map

         /**
          * The loop checks for NULL, so inside, sPtr is safe to use.
          */
         while (sPtr != NULL) {          //For all tokens
//            cout << sPtr;
            cerr << sPtr;
            FastaSeq[entryID] += sPtr;   // assign more token to sequence
            sPtr = strtok(NULL, " ");
         }
      }

      delete [] sArray;      /* NOT OPTIONAL! */
   }

   cerr << endl << endl;
   inFILE.close();

   //print the map
   map <string, string>::const_iterator seq_itr;

   /**
    * You made an iterator but didn't point it to anything.
    * This is bad for the same reason an unchecked pointer to
    * nothing is bad.
    *
    * Imagine a loop like for(x=0; x != 10; x++) but it's not an int,
    * instead you use z.begin() and z.end().  ++ still works.
    */
   seq_itr=FastaSeq.begin();

//   if (seq_itr != FastaSeq.end()){
   while(seq_itr != FastaSeq.end()) {
      cout << seq_itr->first << " ";

      /**
       * ???  Not sure what you're trying to do here.
       * You can't print an iterator, just its contents (first, second)
       */
      // cout << seq_itr << seq_itr->second << endl;
      cout << seq_itr->second << endl;

      /**
       * You can call ++ on an iterator, it's effectively i=i.next();
       */
      seq_itr++;
   }

    return 0;
}

./prog dataset.file sample.list

seq01
seq03
seq99 (not in the dataset)

while(seq_itr != FastaSeq.end())
 { cout << seq_itr->first << " ";        
   cout << seq_itr->second << endl;        /* You can call ++ on an iterator, it's effectively i=i.next();        */       
seq_itr++;    
}

 sPtr = strtok(NULL, " ")

 sPtr = strtok(NULL, " ")

FastaSeq[entryID] += sPtr;   // assign more token to sequence

>seq01 some description protein 
AGCTAC GTACAT C
AGTCGTGT GAT 
CGAGC GGG