Previous Lecture Lecture 4 Next Lecture

Lecture 4, Thu 04/12

Dynamic Array Allocation, Structs, Padding, and Namespaces

Dynamically Allocating Arrays

Example

int x;
cout << “Enter a positive number: “;
cin >> x;
// int intArray[x]; // ERROR IN VisualStudio, NOT g++ / clang++
int* intArray = new int[x]; // LEGAL IN BOTH
for (int i = 0; i < x; i++) {
	intArray[i] = i;
	cout << intArray[i] << endl;
}
// Note: to delete an array on the heap, use delete [] intArray;

Structs

Memory Organization of classes / structs

Padding

Example

class X {
	int a;
	short b;
	char c;
	char d;
};

Padding X

class Y {
	char a;
	int b;
	char c;
	short d;
};

Padding Y

int main() {
	X x;
	Y y;
	cout << "size x " << sizeof(x) << endl; // 8 bytes
	cout << "size y " << sizeof(y) << endl; // 12 bytes???
	return 0;
}

Namespaces

A high-level scenario:

Example

// F1.h
#ifndef F1_H
#define F1_H
#include <iostream>
namespace CS_32_F1 {
	void someFunction() {
		std::cout << "F1.someFunction()" << std::endl;
	}
}
#endif
------------
// F2.h
#ifndef F2_H
#define F2_H
#include <iostream>
namespace CS_32_F2 {
	void someFunction() {
		std::cout << "F2.someFunction()" << std::endl;
	}
}
#endif
------------
#include "F1.h"
#include "F2.h"
int main() {
	using namespace CS_32_F1;
	someFunction(); // F1.someFunction()
	return 0;
}
-----
# Makefile
CXX=g++

# note F1.h and F2.h are not required, but can list them
# to make sure the files exist.
main: main.o F1.h F2.h
	${CXX} -o main -std=C++11 main.o
clean:
	rm -f *.o main

Notes:

Global Namespace

Appending to existing namespaces

Example - Namespaces spanning multiple files

// F1.h
#ifndef F1_H
#define F1_H
#include <iostream>

namespace CS_32_F1 {
	class string {
	public:
		void someFunction();
	};
}
#endif
------------
// F2.h
#ifndef F2_H
#define F2_H
#include <iostream>

namespace CS_32_F2 {
	class string {
	public:
		void someFunction();
	};
}
#endif
------------
// F1.cpp
#include <iostream>
#include "F1.h"

using namespace std;

namespace CS_32_F1 {
	void string::someFunction() {
		cout << "F1.someFunction()" << endl;
	}
}
------------
// F2.cpp
#include <iostream>
#include "F2.h"

using namespace std;

namespace CS_32_F2 {
	void string::someFunction() {
		cout << "F2.someFunction()" << endl;
	}
}
------------
// main.cpp
#include "F1.h"
#include "F2.h"
int main() {
	CS_32_F2::string x;
	x.someFunction(); // prints “F2.someFunction()”
	return 0;
}-------------------------
# Makefile

#CXX=g++

main: main.o Person.o F1.o F2.o
	${CXX} -o main -std=C++11 main.o Person.o F1.o F2.o

clean:
	rm -f *.o main

Specifying something in the global namespace.

Example

// main.cpp
using namespace CS_32_F1;
…
void someFunction() {
	cout << "in some function (global namespace)" << endl;
}

int main() {
	// someFunction(); // which one?? – won’t compile.
	::someFunction(); // knows it’s someFunction in global namespace
}