computers, computers, computers

Cstrings and strings are sequences of characters that offer similar functionality to some extent.

Strings are more convenient than C-strings

C-strings have a “\0” as a terminating character and strings have an opaque implementation where there’s nothing forcing a library provider to implement the strings in a specific way.

A string’s internal structure is more elaborate since there is some extra work that has to be done for many of the operations. ‘Tis the cost of being so nifty. There are checks that have to be made which take up more time and memory. Whereas the C-string does most things automatically because it has a specific way to be implemented.

Strings are better when convenience is preffered, but C-strings are better in situations where time is an issue and many manipulations are necessary.

It’s dangerous to run code like:                 char *myPtr;                 *(myPtr + 2) = ‘0’;

Because the code will not trigger a run-time error and will mess up the program because we did not initialize myPtr and will probably end up using whatever garbage address is stored there in the first place.

Dangling pointers result from releasing dynamically allocated memory while the pointers still exist. In other words, a pointer who’s dereferencing is undefined. You may get a segmentation violation.

Pointer type defined as: typedef int* IntPtr;

Prevent the error in pointer declaration: int *P1, P2; with IntPtr P1, P2; (P1 and P2 are pointer variables)

  A dynamic array is an array whose size is determined when the program is running, not when its being written.

Since b is a pointer variable that points to an address “p=b;” causes p to point to the same location as b.

Creating dynamic arrays require using the new operator                 type double:                                 typedef double *DblPtr                                 DblPtr d;                                 d = new double[10]; *d can now be used as if it were an ordinary array. It is a pointer to d[0]

When finished with the array, you should release it to free the space using “delete []”

d[i] = *(d+i)

&d[i] = &*(d+i) which equals d+I because * and & cancel e.o out

++ and -- can be used

Two pointers of the same type can be subtracted to obtain the number of indexed variables between

Pointer arithmetic:

for (int i=0; i< array_size; i++)                                 cout << *(d+i) << “ “;       (same as cout << d[i] << “ “;)

void myStrcpy (char d st[], char src[])     voidm(char *d, char *s)                 voidm(char *dst, char *src)        

inti;                                                                        char *d = dst, *s = src;                     while ( *dst++ = *src++)

                for (i=0; src[i] != ‘\0’; i++)              or            while (*s != ‘\0’)               or                            ;

                                dst[i] = src[i];                                                     *d++ = *s++;

                dst[i] = ‘\0’;                                                        *d = ‘\0’;

  fill_array (int a[], int size) is the same as fill_array(int *a, int size)

  To create a multidimensional dynamic array (arrays of arrays) you must first create a one-dimensional dynamic array. Start with a new definition and then create a dynamic array of pointers. For each pointer in that array, create a dynamic array of its type.

                Typedef int* IntArrayPtr;                 IntArrayPtr *m = new IntArrayPtr[3];                                 for (int i=o; int<3; i++)                                                 m[i] new int[4];

To delete said dynamic array;

                for(I = 0; i<3;i++)                                 delete [] m[i];   delete each int array                                 delete [] m;        delete the array with the addresses of the int arrays

It has to be erased in the reverse of how it was built because we need to keep the array with the addresses so we can release the individual arrays. Should we erase that one first then we lose the pointers to the addresses and may not be able to release those arrays’ spaces any more.

  #include <iostream>

#include <string>

using namespace std;

int main() {

char input[300], *p, *q[300], **r = q;

Input @500

300 chars

  p@

q@2000

300 chars

  R @ 2000

  cin.getline(input, 300);

for (p = input; *p; p++)

switch (tolower(*p)) {

case 'e':

*r++ = p;

break;

case '.':

case '\'':

case ' ':

*p = '\0';

break;

}

*r = 0;

for (r = q; *r; r++)

cout << *r << " ";

cout << endl;

}

  q is a static array of 300 pointers to chars.

  **r is a pointer to a char pointer.

The for loop makes the program read everything the user input until \0.

*p is used as a condition making any char that is not ‘\0’ true.

*p points to the position in the array that is being evaluated.

Think is passed over because there is no case to equal those chars. Now we found a space and now *p overwritten to equal a \0 at that space.

Later on we find a period and the same thing that happened for the space, happens for the period.

Dereference r then use the value in r to assign it to p then post-increment the variable in r. Store the position of the ‘e’ in the q array.

o(-.- )o <zzzzzzz

O(_-_ )O <zzzzzzz

Then *r will become 0.

In the for loop r is initialized as q, condition *q and r is post-incremented.

We search the q array and cout the dereference of r (which is a pointer to char) which will output the cstrings.

Vectors are a template class and are like dynamic arrays and they have a base type. To declare a vector:                 vector <type>v; (empty vector) <int> identifies vector as a template class (string, char, int…)                                 max<int>(10,15);              max<double>(2.0,3.0);                                 vectorname(template)<vectortype>(object);

Template- incomplete piece of source code where we haven’t specified certain things like values. Only when a type specified will the source code be complete and ready to have machine code generated from it.

You can assign values to the vector’s elements using square brackets.                  V[i]=42 You can’t initialize a vector that’s empty or inexistent.

To create vector elements push_back is used.                 vector<double>sample;                 sample.push_back(0.0);  1 element?                 sample.push_back(1.1);               2 elements?                 sample.push_back(2.2);  3 elements?

To know the size of a vector you use vectorname.size()

Vector class member function sizes return unsigned int’s.

Unsigned int’s are non-negative integers or different interpretations of the bit pattern. To ask  for size you must write something like this:                 for (unsigned int i=0; i < sample.size(); i++) else you get warnings from the compiler.

To make a vector with elements you write:                 vector<int>v(10); initializes the first 10 elements to 0, v.size() would return 10, you can use [].

Using [] to assign a value bigger than the vector’s size may not generate an error, but the program may misbehave. Assignment operators must make independent copies of the right hand vector.

Hrrgh…

A vector’s capacity is the number of elements allocated in memory. They are accessible using the capacity() member function. While size is the number of initialized elements. Should the vector run out of space, the capacity increases by the size the vector currently is. (Try doubling the size of the vector beforehand)

When efficiency is an issue, member function reserve can increase the capacity of a vector: v.reserve(32); (32 more spaces are guaranteed to be available) or v.reserve(v.size()+10); (10 spaces more are guaranteed)

Resize, on the other hand, can be used to shrink a vector: v.resize(24); (elements beyond the 24th space are lost)

Size = how many initialized elements.  Capacity = how many elements it can hold.

Multi-dimensional arrays can be seen as the first range are the rows and the second are the columns. Ex.                char page [30] [100];                       (30 rows and 100 columns)

OR

Every one in 30 arrays has 100 elements.

Making “size” a parameter instead of using a constant, even if the condition is true, makes it more general and lets the array have more than one size possibility.

Sequential search is just that… It searches in sequence until it finds the value it seeks in an array. If found it returns an index value, but if it does not it should return something else like -1.

Conditional value- it’s like a shortened if-else

<condition> ? <true value> : <false value>

They are sequences of characters that offer similar functionality to some extent.

Strings are more convenient than C-strings

C-strings have a "\0" as a terminating character and strings have an opaque implementation where there's nothing forcing a library provider to implement the strings in a specific way.

A string's internal structure is more elaborate since there is some extra work that has to be done for many of the operations. 'Tis the cost of being so nifty. There are checks that have to be made which take up more time and memory. Whereas the C-string does most things automatically because it has a specific way to be implemented.

Visualization and "audibilization" of 15 Sorting Algorithms in 6 Minutes. Sorts random shuffles of integers, with both speed and the number of items adapted ...

http://www-users.cs.york.ac.uk/susan/joke/foot.htm

Wow that loan problem is horrible

In other news The beauty of functions and strings is amazing

but working with loans is horrible

so

many

quizzes

I'm on Chapter 3 and I just noticed that the amount of quizzes are about the sum of quizzes for chapters 1 and 2

The first lab was pretty easy considering I blanked out with the first 2 problems...

I found this to be pretty handy and could be used for future reference so I'll just keep it here.

I've also noticed I detest working the terminal. I think I'll stick to using Dev-C++ for when I work on my laptop.