Basic Requirements for all Programming Assignments

Overview

Every class defined in an assignment must be created in its' own .h and .cpp files. You may not define more than one class in a file. See Coding Problems below.



Every member variable defined in a class must be private. If a variable must be accessible from outside the class then a get and a set function must be created for it.



A class must represent a single object of which multiple instances can be created. A single class may not be created to represent a collection of objects. See Coding Problems below.



A class has defined responsibilities. These may not be handled by other objects. For example: If a class represents an object that generates data in a simulation then that clsss must be the one containing the function to generate the data. It may not be generated by a function in another class.



In every programming assignment there must be a simulation class (you may select the appropriate name). The main() function should do nothing except create an instance of that simulation object and pass control to it.

Common Programming Assignment Coding Problems

Overview

Defining classes in .h and .cpp files.



Creating a class to represent multiple instances of an object.



Use of the data parser class provided with each programming assignment.



There are two classes in an application and each must have a pointer to an instance of the other.

The compiler reports that a function is an "unresolved external symbol". The error may also report "fatal error LNK1120: 1 unresolved externals"



The compiler reports something like: "error C2011: 'SomeClass' : 'class' type redefinition ". The error may also report "fatal error LNK1120: 1 unresolved externals"

Defining classes in .h and .cpp files.

Object1.h file:

	//-----------------------------------------------
	// File: Object1.h
	// Header file defining the class
	//-----------------------------------------------
	#pragma once;
	class Object1
	{
		private:
			//  Define all member variables here
		public:
			//  Prototype all member functions here
	};
	

	//-----------------------------------------------
	// File: Object 1.cpp
	// Implementation file defining the functions
	//-----------------------------------------------
	#include "Object1.h"
	//-----------------------------------------------
	// Default Constructor
	//-----------------------------------------------
	Object1::Object1()
	{
	 // Initialize all member variagbles
	};
	//-----------------------------------------------
	// Destructor
	//-----------------------------------------------
	Object1::~Object1()
	{
	 // Clean up any external memory allocated by this instance
	};
	

	Objec1 *o1 = new Object1(); // Create an instance of a class 
	Objec2 *o2 = new Object2(); // Create an instance of a class 
			

	//-----------------------------------------------
	// File: Objects.h
	// Header file defining the class
	//-----------------------------------------------
	#pragma once;
	class Object1
	{
		private:
			//  Define all member variables here
		public:
			//  Prototype all member functions here
	};
	class Object2
	{
		private:
			//  Define all member variables here
		public:
			//  Prototype all member functions here
	};
			

In many of the programming assignments a collection of a certain class is needed, for example Jets, Vehicles, Sensors, Monitors, Bugs, etc. You must create a class to represent a single instance (Jet, Vehicle, Sensor, Monitor, Bug). Somewhere else, in another class, you can create a collection of instances of this class.

	//-----------------------------------------------
	// File: Sensor.h
	// Header file defining a sensor object
	//-----------------------------------------------
	#pragma once;
	class Sensor
	{
		private:
			//  Define all member variables here
		public:
			//  Prototype all member functions here
	}; 
			

	vector m_vTheSensors;  // Vector of all sensors used in this simulation.
			

	//-----------------------------------------------
	// File: Sensor.h
	// Header file defining a sensor object
	//-----------------------------------------------
	#pragma once;
	class Sensor
	{
		private:
			vector m_vTheSensors;  // Vector of all sensors used in this simulation.
			//  Define all member variables here
		public:
			//  Prototype all member functions here
	}; 
			

A data parser class is provided for each programming assignment. All the parameters to the "get data" functions in this class are pointers to variables and arrays.

	bool DataParser::getObjectData(char *objName, char *objType, int *objID, double *objDVal) 
	{
		char Name[64];
		char Type[64];
		int ID;
		int DVal;
		// Input the object name into array Name from the data file
		strcpy(objName, Name); // Copy array Name into array pointed to by objName
		// Input the object type into array Type from the data file
		strcpy(objType, Type); // Copy array Type into array pointed to by objType 
		// Input the object ID into int ID from the data file
		// Note: this will be input as a string from the data file then converted to an int with the
		//    function atoi.
		*objID = ID; // Copy int ID into int variable pointed to by objID
		// Input the object double value into double DVal from the data file
		// Note: this will be input as a string from the data file then converted to a double with the
		//    function atof.
		*objDVal = DVal; // Copy double DVal into double variable pointed to by objDVal
	}
			

	char m_sName[64];
	char m_sType[64];
	int m_iID;
	int m_dDVal;
	DataParser *sc = new DataParser("SimData.txt"); // Create the data parser and give it the data file name.
	sc->getObjectData(m_sName, m_sType, &m_iID, &m_dDval);// Get all the data from the data parser
	// NOTE: You are really passing the starting address of the char arrays
			

	char *m_sName;
	char *m_sType;
	int *m_iID;
	int *m_dDVal;
	DataParser *sc = new DataParser("SimData.txt"); // Create the data parser and give it the data file name.
	sc->getObjectData(m_sName, m_sType, m_iID, m_dDval);// Crash and burn
	// NOTE: None of the pointers passed to getObjectData are really pointing to places in memory.
			

	//---------------------------------------
	// Class1.h
	// Definition of Class1
	//---------------------------------------
	#pragma once;
	// Any needed #include statements are here

	class Class2;		 // This is a forward definition 

	class Class1		 // This begins the definition of Class1 in Class1.h 
	{
		private:
			Class2 *m_C2Ptr;	 // Define a pointer to Class2 instance 
			 // Other variable definitions are here 

		public:
			Class1();
			~Class1();
			 // Other function prototypes are here 
	}
			

	//---------------------------------------
	// Class2.h
	// Definition of Class2
	//---------------------------------------
	#pragma once;
	
	#include "Class1.h"		 // Include header for the already defined Class1 

	 // Any other needed #include statements are here 

	class Class2		 // This begins the definition of Class2 in Class2.h 
	{
		private:
			Class1 *m_C1Ptr;	 // Define a pointer to Class1 instance 
			 // Other variable definitions are here 

		public:
			Class2();
			~Class2();
			 // Other function prototypes are here 
	}
			

A class must have a get function that takes a char array parameter and copies a char array class member variable into that string.

	void SomeClass::getName(char *name)
	{
		strcpy(name, m_sName); 
	}
			

	SomeClass *sc = new SomeClass(); // Create an instance of a class
	char nameArr[32]; 
	sc->getName(nameArr);// Call the function passing in the char array. 
	// NOTE: You are really passing the starting address of the char array
			

	void SomeClass::getName(char *name)
	{
		name = m_sName; 
	}
			

	void SomeClass::getName(char *name)
	{
		strcpy(m_sName, name); 
	}
			

A class must have a function that returns a pointer to an instance of a struct or class.

	MyClass *getMyClassInstance(); // Create and return an instance of MyClass
			

	MyClass *SomeClass::getMyClassInstance()
	{
		MyClass *mc = new MyClass();
 		// Code to finish initialization of the MyClass instance is here
		return mc;
	}
			

	MyClass SomeClass::*getMyClassInstance()
	{
		MyClass *mc = new MyClass();
 		// Code to finish initialization of the MyClass instance is here
		return mc;
	}
			

At some point in code you must compare two char array strings to determine if they hold the same string or if one alphabetically comes before the other.

	char str1[32];
	char str2[32];
	char str3[32];
	strcpy(str1, "Able"); // Copy string constant "Able" into str1
	strcpy(str2, "Able"); // Copy string constant "Able" into str2
	strcpy(str3, "Baker");  // Copy string constant "Baker" into str3
			

	if(strcmp(str1, str2) == 0)
	{
		cout << "Strings str1 and str2 hold the same string.\n";
	}
			

	if(strcmp(str1, str3) < 0)
	{
		cout << "String str1 alphabetically comes before string str3.\n";
	}
			

	if(strcmp(str3, str1) > 0)
	{
		cout << "String str1 alphabetically comes before string str3.\n";
	}
			

	if(str1 == str2)
	{
		cout << "Strings str1 and str2 hold the same string.\n";
	}
			

	if(str1 < str3)
	{
		cout << "String str1 alphabetically comes before string str3.\n";
	}
			

	if(str3 > str1)
	{
		cout << "String str1 alphabetically comes before string str3.\n";
	}
			

Common Compiler Problems

The compiler reports that a function is an unresolved external symbol. The error may also report fatal error LNK1120: 1 unresolved externals.

	void GetIntValue()
	{
		return m_iVal;  // m_iVal is an int member variable of SomeClass 
	}
			

The compiler reports something like:
error C2011: 'SomeClass' : 'class' type redefinition.

	// Place #define statements here

	class SomeClass
	{
		// Place class member variables and function prototypes here.
	}