Smackbilly fucked around with this message at 00:06 on May 13, 2008

Smackbilly fucked around with this message at 00:44 on May 30, 2008

struct Directions {
  enum Direction { North, South, East, West };
  const unsigned int NUMDIRECTIONS = 4;
};

Smackbilly fucked around with this message at 13:04 on Jun 5, 2008

class Foo {
public:
  struct States {
    enum State { Initiailzed, InProgress, Aborted, Completed };
    static const unsigned int NUMSTATES = 3;
  };
};

Smackbilly fucked around with this message at 16:26 on Jun 6, 2008

int intArrA[5] = {1, 2, 3, 4, 5};
int intArrB[7] = {10, 20, 30, 40, 50, 60, 70};

intArrA = intArrB; // doesn't work!

char charArrA[5] = "Bill";
char charArrB[7] = "Ernest";

charArrA = charArrB; // doesn't work either!

charArrA = "Eric"; // also doesn't work 
// ^^^ This kind of syntax only works in initializations. 

Smackbilly fucked around with this message at 15:39 on Jul 2, 2008

Smackbilly fucked around with this message at 18:37 on Jul 7, 2008

Smackbilly fucked around with this message at 20:26 on Jul 20, 2008

Smackbilly fucked around with this message at 21:52 on Jul 20, 2008

Smackbilly fucked around with this message at 16:33 on Jul 22, 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

This_object_impelments_FOO* foo = new This_object_implements_FOO();
FOO* thingie = foo;

Smackbilly fucked around with this message at 03:29 on Oct 25, 2008