Common Programming Assignment Coding Problems

Overview

Note: The Code Vault contains many good examples to help you with programming assignments. But, there is nothing in the Code Vault that you can copy and paste directly into your programming assignment code and expect it to work. You must carefully study each line of the copied code to see if it will work correctly for your application.

A class must have one or more functions that use a reference parameter to return a value to the calling function



A class must have one or more functions that use a pointer parameter to return a value to the calling function




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




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




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




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




The delete function in a binary tree must return a pointer to the item removed but it keeps returning NULL or the program crashes




The delete function in a binary tree must return a pointer to the item removed but item to be removed has two children




A function must call a remove function in a linked list or a binary tree and return to its' caller what that function returned or return NULL if nothing was found to remove

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"

A class must have one or more functions that use a reference parameter to return a value to the calling function.

	void SomeClass::getIntValRef(int& a)
	{
		a = m_iIntVal; 
	}
			

	SomeClass *sc = new SomeClass(); // Create an instance of a class
	int iVal = 0;
	sc->getIntVal(iVal);// Call the function passing the name of the variable
			

	void SomeClass::getIntValRef(int& a)
	{
		&a = m_iIntVal; 
	}
			

A class must have one or more functions that use a pointer parameter to return a value to the calling function.

	void SomeClass::getIntValPtr(int *a)
	{
		*a = m_iIntVal; 
	}
			

	SomeClass *sc = new SomeClass(); // Create an instance of a class
	int iVal = 0;
	sc->getIntValPtr(&iVal);// Call the function passing in the address of the varaible
			

	void SomeClass::getIntVal(int& a)
	{
		a = m_iIntVal; 
	}
			

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

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

	SomeClass *sc = new SomeClass(); // Create an instance of a class
	char nameArr[32] = "Bob"; // You can create and initialize a char array
	// You cannot set a char array after creating it with code like: nameArr="Bob"
	sc->setName(nameArr);// Call the function passing in the char array. 
	// NOTE: You are really passing the starting address of the char array
			

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

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

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";
	}
			

The delete function in a binary tree must return a pointer to the item removed but it keeps returning NULL or the program crashes.

	TreeNode *deleteNode(int key)
	{
		TreeNode *temp;
		TreeNode *back;
		// All the code is here to remove the node from the tree if key is found.
		// Temp is now pointing to NULL or the one to return.
		return temp;
	}
		

	TreeNode *MyTreeClass::deleteNode(int key)
	{
		TreeNode *temp;
		TreeNode *back;
		// All the code is here to remove the node from the tree if key is found.
		// Temp is now pointing to NULL or the one to return.
		delete temp;
		return temp;
	}
			

The delete function in a binary tree must return a pointer to the item removed but item to be removed has two children.

	TreeNode *MyTreeClass::deleteNode(int key)
	{
    		TreeNode *back;
    		TreeNode *temp;
    		TreeNode *delParent;    // Parent of node to delete
    		TreeNode *delNode;      // Node to delete
		// All code to do the searching and removing of a node with no children or.
		// only a node with one child on the left or right is here.

 		       else // Case 2: Deleting node with two children 
		        {
				// Find the replacement value.  Locate the node  
				// containing the largest value smaller than the 
				// key of the node being deleted.                
            			temp = delNode->left;
            			back = delNode;
            			while(temp->right != NULL)
            			{
                			back = temp;
                			temp = temp->right;
            			}
            			// Create a copy of the node to be deleted 
				TreeNode *retNode = new TreeNode();  // Create the new TreeNode
				TreeNode *rt, *lf;	// Create temporary pointers
				rt = delNode->right;	// Copy and save pointers from delNode
				lf = delNode->left;
				*retNode = *delNode;	// Block copy delNode into retNode
				retNode->left = retNode->right = NULL;	// Clear pointers in retNode
        			// Copy the replacement values into the node to be deleted 
				*delNode = *temp;
				delNode->left = lf;	// Restore pointers in delNode
				delNode->right = rt;

            			// Remove the replacement node from the tree 
            			if(back == delNode)
                			back->left = temp->left;
            			else
                			back->right = temp->left;
				delete temp; // Delete the node actually removed from the tree.
            			return retNode; // Return the copy of the node overwritten to remove it.
        		}// end else 2 children
    		}// end else at least 1 child
	}// end delete function
			

	TreeNode *MyTreeClass::deleteNode(int key)
	{
    		TreeNode *back;
    		TreeNode *temp;
    		TreeNode *delParent;    // Parent of node to delete
    		TreeNode *delNode;      // Node to delete
		// All code to do the searching and removing of a node with no children or.
		// only a node with one child on the left or right is here.

 		       else // Case 2: Deleting node with two children 
		        {
				// Find the replacement value.  Locate the node  
				// containing the largest value smaller than the 
				// key of the node being deleted.                
            			temp = delNode->left;
            			back = delNode;
            			while(temp->right != NULL)
            			{
                			back = temp;
                			temp = temp->right;
            			}
 				TreeNode *rt, *lf;	// Create temporary pointers
				rt = delNode->right;	// Copy and save pointers from delNode
				lf = delNode->left;
	    			// Copy the replacement node into the node to be deleted 
				*delNode = *temp;
				delNode->left = lf;	// Restore pointers in delNode
				delNode->right = rt;

				FAILED TO MAKE A COPY OF THE NODE BEFORE OVERWRITING  

            			// Remove the replacement node from the tree 
            			if(back == delNode)
                			back->left = temp->left;
            			else
                			back->right = temp->left;
            			return temp; // Return the node removed from the tree.
 				RETURNING THE WRONG NODE.  THIS WAS USED TO OVERWRITE THE ONE REMOVED.  
       			}// end else 2 children
    		}// end else at least 1 child
	}// end delete function
			

A function must call a remove function in a linked list or a binary tree and return to its' caller what that function returned or return NULL if nothing was found to remove.

	Node *SomeClass::removeNode(int key)
	{
		return m_pCollection->delete(key);// Return whatever is returned by calling delete.
	}
		

	Node *SomeClass::removeNode(int key)
	{
		if(m_pCollection->delete(key) != NULL)
			return m_pCollection->delete(key);// Can't return anything already deleted.
		else
			return NULL;
	}
			

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.
	}