Avenging Dentist fucked around with this message at 23:14 on Oct 8, 2008

Avenging Dentist fucked around with this message at 00:03 on Oct 9, 2008

Avenging Dentist fucked around with this message at 03:03 on Oct 9, 2008

DontMockMySmock fucked around with this message at 18:31 on Oct 9, 2008

#define BUFFER_SIZE 10
#define ITEM_SIZE 1

const char *filePath = "/path/to/file.txt"; // this is the path of the file we want to read
FILE *file; // a pointer to the stream of bytes that represent our file

// we want space enough to hold BUFFER_SIZE bytes, plus one byte for
// the NUL string terminator (since we're printing strings)
char buf[BUFFER_SIZE + 1];

// fread() returns how many items it read, which is important for us,
// because we can use that information to know where to place the NUL terminator
int n;

// open the file for reading
file = fopen(filePath, "r");
if (file == NULL)
{
	// fopen() returns NULL if it fails to open the file. oh poo poo! bail!
	return 1;
}

// 0. set n to the number of items fread() was able to read. if this number is 0, we're done.
// 1. pass in our data buffer for the first argument. this is where fread() will place the data it sucks in from the file.
// 2. each item we read will be ITEM_SIZE bytes long (which is just 1 byte long, the size of a char).
// 3. we're going to read BUFFER_SIZE items, which is 10. read 10 items that are each
// ITEM_SIZE bytes long. for us, this means we'll read 10 bytes of data at a time.
// 4. read this data from |file|.
while ((n = fread(buf, ITEM_SIZE, CHAR_BUFFER, file)) != 0)
{
	// right now, the |buf| data buffer contains n * ITEM_SIZE bytes of data (10 bytes).
	// we can do whatever we want with this. let's just say it's a text file and
	// we're just going to print it to the console. that means we have to add a
	// NUL terminator to the end of the string we're about to print.
	
	buf[n * ITEM_SIZE] = 0; // n conveniently tells us where to place the NUL terminator.
	printf("%s", buf); // hurf durf print string
}

Mikey-San fucked around with this message at 20:23 on Oct 9, 2008

• If your algorithm allows you to precompute your sampling coordinates, you can just scan over the file once and selectively materialize exactly the k-vectors you need. You might be able to skip some blocks this way.
  
• If the file's small enough to fit into the memory space of your machine, you can try mmapping it. That won't magically make your disk-access patterns more efficient, but it will likely make better use of the disk cache if you're still using the random-access patterns.
  
• If you might need to run this computation many times on the same file, you might consider pre-processing it into a new file which records the k-vectors compactly.
  
• Similarly, if you have control over the production of the original file, you might want to consider altering it to place the k-vectors sequentially. Of course, that depends on the efficiency needs of the producer and any other consumers out there.
  

StringTable::StringTable(ifstream & infile)
{
   // Initiates the string vector that will represent the rows
   vector<string> vecRows;
   const string sep = "#";
   string s;

   // While the end of the file is not reached
   while (!infile.eof())
   {
        // If readAllItems returns true, that means what it just
        // read in was not the seperator and is part of the data for the row
        if (readAllItems(s, infile, sep))
        {
                // Pushes back the row one element with the data
                // that was just read in
                vecRows.push_back(s);
				
        } // end if

        // readAllItems read in the seperator, signifying the
        // end of the row
        else
        {
                // Pushes back on the rows, makes room for a new
                // one
                twoDimStrVec.push_back(vecRows);

                // Clears this instance of vecRows
                vecRows.clear();
				
        }  // end else
   } // end while
} // end StringTable constructor

StringTable::StringTable(ifstream & infile)
{
    bool insertComplete;
    int i;
    const string sep = "#";
    string s;
    vector<string> vecRows;
    vector< vector <string> >::iterator tableItr;

    while (readAllItems(s, infile, sep))
    {
        i = 0;
        insertComplete = false;

        // Clears the row
        vecRows.clear();

        // Pushes back each individual element in the row
        do
        {
            vecRows.push_back(s);
        }
        while (readAllItems(s, infile, sep));

        // If the table is empty, just push back the first element to avoid
        // a seg fault
        if (twoDimStrVec.empty())
        {
            twoDimStrVec.push_back(vecRows);
        }
		
	// If it's not empty, sort it
        else
        {
		// Iterator begins where the beginning of the table is, traverses the entire twoDimStrVec.
		for (tableItr = twoDimStrVec.begin(); !insertComplete && tableItr != twoDimStrVec.end(); tableItr++)
		{
			if (tableItr == (twoDimStrVec.end() - 1))
			{
				twoDimStrVec.insert(tableItr,vecRows);
				insertComplete = true;
			}

			else if (vecRows[0] <= twoDimStrVec[i][0])
			{
				twoDimStrVec.insert(tableItr,vecRows);
				insertComplete = true;
			} 

			else
				i++;
					
		} // end for-loop
        } // end else
    } // end while loop
} // end constructor

Whilst farting I fucked around with this message at 22:17 on Oct 10, 2008

floWenoL fucked around with this message at 23:43 on Oct 10, 2008

• Do not use macros as a cheap form of inlining.
  
• Do not use macros as a cheap form of polymorphism.
  
• Do not use macros to "override" external declarations, unless you are absolutely forced to.
  
• Do not use macros to implement your own private syntax.
  
• etc.
  

template <class D>
reference get_default(D const&, mpl::false_) const
{
  return arg.value;
}

The Red Baron fucked around with this message at 21:18 on Oct 11, 2008

for (*tableItr = twoDimStrVec->begin(); !insertComplete && *tableItr != twoDimStrVec->end(); tableItr++)
{
           if (vecRows[0] < &twoDimStrVec[i][0])
           {
                    twoDimStrVec->insert(*tableItr,&vecRows);
                    insertComplete = true;
           } 

           else if (*tableItr == (twoDimStrVec->end() - 1))
           {
                    twoDimStrVec->insert(*tableItr,&vecRows);
                    insertComplete = true;
           }

           else 
                    i++; 
} // end for-loop 

const vector<string> & StringTable::operator[](int i) const
{
    return twoDimStrVec[i];
}

Whilst farting I fucked around with this message at 01:10 on Oct 12, 2008

// Assuming type: vector< vector <string>* >* twoDimStrVec
// Assuming type: vector<string> vecRows

[b]// This declares tableItr as a pointer-to-an-iterator but allocates
// no memory for the actual iterator[/b]
vector< vector <string>* >::iterator *tableItr;

for (*tableItr = twoDimStrVec->begin(); 
!insertComplete && *tableItr != twoDimStrVec->end(); 
tableItr++) [b]// here you are incrementing the POINTER not the iterator it points to[/b]
{
           [b]// twoDimStrVec is type pointer-to-vector<pointer-to-vector<string>>[/b]
           [b]// twoDimStrVec[i] is the ith offset from the pointer above. You're not[/b]
           [b]//   dereferencing the pointer, so it takes the offset of the pointer[/b]
           [b]//   as if it were a pointer to the first element of an array. The result is a[/b]
           [b]//   vector<pointer-to-vector<string > >, as if it were the ith elemenent in[/b]
           [b]//   an array of vectors of pointers to vectors of strings. But twoDimStrVec is[/b]
           [b]//   not an array, so it's dereferencing some random memory location[/b]
           [b]// twoDimStrVec[i][0] is the 0th element of the vector which supposedly exists at[/b]
           [b]//   that random memory location, a pointer to a vector of strings.[/b]
           [b]// &twoDimStrVec[i][0] is the address of that vector that doesn't exist [/b]
           [b]// I'm assuming vecRows is type vector<string> so here you're comparing a string to[/b]
           [b]//   the address of a pointer to a vector of strings[/b]
           if (vecRows[0] < &twoDimStrVec[i][0])
           {
                    [b]// Here you modify the container you are iterating through, which[/b]
                    [b]//   invalidates your iterators. I know you are going to exit the loop[/b]
                    [b]//   right away because you set insertComplete to true, but the increment[/b]
                    [b]//   statement still executes with undefined behavior. Why not use a[/b]
                    [b]//   break statement instead?[/b]
                    twoDimStrVec->insert(*tableItr,&vecRows);
                    insertComplete = true;
           } 

           else if (*tableItr == (twoDimStrVec->end() - 1))
           {
                    [b]// Same as above[/b]
                    twoDimStrVec->insert(*tableItr,&vecRows);
                    insertComplete = true;
           }

           else 
                    i++; [b]// Why are you using i to index things when you have an iterator?[/b]
} // end for-loop 

// Assuming type: vector< vector <string>* >* twoDimStrVec
// Assuming type: vector<string> vecRows

vector< vector <string>* >::iterator tableItr; // Just an iterator, not a pointer

for (tableItr = twoDimStrVec->begin(); tableItr != twoDimStrVec->end(); tableItr++)
{
           // tableItr is an interator-into-vector<pointer-to-vector<string> >
           // *tableItr is the current pointer-to-vector<string> that you are iterating on
           // **tableItr is the current vector<string> being pointed to
           // (**tableItr)[0] is the first string in that vector
           if (vecRows[0] < (**tableItr)[0]) 
           {
                    twoDimStrVec->insert(tableItr,&vecRows);
                    break;
           } 

           else if (tableItr == (twoDimStrVec->end() - 1))
           {
                    twoDimStrVec->insert(tableItr,&vecRows);
                    break;
           }
} // end for-loop 

// Assuming type: vector< vector <string>* > twoDimStrVec
// Assuming type: vector<string> vecRows

vector< vector <string>* >::iterator tableItr; // Just an iterator, not a pointer

for (tableItr = twoDimStrVec.begin(); tableItr != twoDimStrVec.end(); tableItr++)
{
           // tableItr is an interator-into-vector<pointer-to-vector<string> >
           // *tableItr is the current pointer-to-vector<string> that you are iterating on
           // **tableItr is the current vector<string> being pointed to
           // (**tableItr)[0] is the first string in that vector
           if (vecRows[0] < (**tableItr)[0]) 
           {
                    twoDimStrVec.insert(tableItr,&vecRows);
                    break;
           } 

           else if (tableItr == (twoDimStrVec->end() - 1))
           {
                    twoDimStrVec.insert(tableItr,&vecRows);
                    break;
           }
} // end for-loop 

Smackbilly fucked around with this message at 02:38 on Oct 12, 2008

Whilst farting I fucked around with this message at 03:04 on Oct 12, 2008