C/C++ Summary at USC

Initialization of instance variables in Object

1. Primitive variables: if does not initialized explicitly in default constructor, it will not be initialized.
2. Object variables: it will be initialized by its own default constructor.

Dangling Pointers

Pointer to dynamic data will exists until we do delete

#include <iostream>

using namespace std;


// once n goes out of scope 
// its memory location can be used for other things
int* dangle() {
  int n = 12;   // local int with value 12

  return &n;    // BAD--can cause weird results or crashes.
}

int *ok() {
  int *q = new int;
  *q = 12;           // dynamically allocated int with value 12
  return q;
}

int main() {

  int *p;

  int *p2;

  p = dangle();  // points to some memory that may have changed
                 // and no longer necessarily even stores an int

  cout << *p << endl;    // try adding the following line
  cout << "*p: " << *p << endl;

  p2 = ok();     // points to dynamic data: exists until we do delete

  cout << "changed only p2..." << endl;

  cout << "*p: " << *p << endl;

  cout << "*p2: " << *p2 << endl;

  return 0;
}

Memory Leaks

Examples:

Ex 1 (run out of memory eventually)

char * p;
for (int i = 0; i < 100000; i++) {
 p = new char;
} 

Ex 2 (common beginner mistake)

char * p = new char;
char * tmp = new char;
tmp = p; // just wasted old *tmp 

Ex 3
This is a valid thing to do; but how do we not lose the
memory…(and risk running out of space later)?

 void myFunc() {
 char * c = new char;
 // use pointer and dyn data here
} // c goes out of scope 

Aliasing

#include <iostream>
#include <string>

using namespace std;

class Student {
public: 
    Student() {
        name = "";
        score = 0;
    }
    string getName() {
        return name;
    }
    int getScore() {
        return score;
    }
    void setScore(int score) {
        this->score = score;
    }
private:
    string name;
    int score;
};

int main(int argc, char *argv[]) {
    Student *p, *r;
    p = new Student();
    p->setScore(10);
    r = new Student();
    r->setScore(50);
    cout << "p: "<< p->getScore() << endl;
    cout << "r: "<< r->getScore() << endl;


    *p = *r;//copy
    cout << p->getScore() << endl;//50
    r->setScore(0);
    cout << p->getScore() << endl;//50

//    p = r;
//    cout << p->getScore() << endl;//50
//    r->setScore(0);
//    cout << p->getScore() << endl;//0


}

Pointer vs Arrays

Static array can be assigned to dynamic array, but we cannot reverse the operation

char a[5];
char *b = new char[5];
a[0] = ‘x’;
b[0] = ‘y’;
cout << *a;
cout << *b;
cout << b[0];
a = b; // illegal
b = a; // legal
b[1] = ‘m’;
cout << a[1]; // m 

Array parameters revisited

//Also, parameter types interchangeable. Can declare
//the following function either of these two ways:
 void printArray(int *arr, int size);
 void printArray(int arr[], int size);

//Can pass either static or dynamic array to the function:
int a[10];
int *b = new int[10];
printArray(a, 10);
printArray(b, 10);

Sign Extension of C

for a char (signed char) if we convert it to int, first it will check the sign of the original char. If the sign is negative, all the extended bit will be 1, otherwise the extended bit will be 0.

e.g.
*reminder: each char has 8bits and each int has 32bits

Example1:
char a = 0x88;
int b = (int)a;
Because the MSB of a is 1, it is a negative char and all the extended bit would be 1. Therefore b would be 0xffffff88;

Example2:
char a = 0x78;
int b = (int)a;
Because the MSB of a is 0, it si a positive char and all the extended bit would be 0. Therefore b would be 0x00000078;

The conversion is a signed extension or a unsigned extension depends on the type of the source data but not the destination data.
For example, if we want to convert a char to a unsigned int, it is still the signed extension, because char is a signed data type. But if we want to convert a unsigned char to int, it is unsigned extension, because unsigned char is an unsigned data type.