Saving And Loading Varibles

void save( char * name, int energy){

FILE *fp; // create a file pointer


if((fp = fopen("c:\\foo.txt", "w")) == NULL){ // open file for writing. if your're using linux, subtitute the file  path
printf("\n\nERROR: could not open file. \n");
return;
}

fprintf(fp, "%s \n", name); // this puts the   string pointed to by name to the file. check how the function is fprintf()  not printf()

fprintf(fp, " %d \n", energy); // this puts the interget var

fclose(fp);// this closes the file

//now, check the file  to see if it worked. 

}

#include <stdio.h>
#include <string.h>

// This structure will hold the variables that
// you need to save
struct tagSAVE
{
char name[50];
char level[50];
char boss[50];
};


///////////////////////////////////////
// PROTOTYPES
///////////////////////////////////////
bool read_save(tagSAVE &);
bool save(tagSAVE &);




///////////////////////////////////////
// FUCTIONS
///////////////////////////////////////

// #####################################################
// main function

int main(){

	// instance of the save structure
	tagSAVE sav; 

	// Clear the structure because if probably
	// has garbage inside
	memset(&sav,0,sizeof(tagSAVE)); 

	// See if there is a file already in place,
	// if not, then ask for inputs.
	if(read_save(sav)){ // the functions return true if 
						// there is a file.

		printf("> file found. I has these variables:\n");

		printf("%s\n", sav.name);
		printf("%s\n", sav.level);
		printf("%s\n", sav.boss);

		printf("\n");

	}// end if

	else{ // the functioned read_save returned false
		 // meaning there was no file.

		//Get the contents to put in the file
		printf("enter name: ");
		gets(sav.name);

		printf("enter level: ");
		gets(sav.level);

		printf("enter boss name: ");
		gets(sav.boss);


		// save the contents you just got
		if(save(sav)) // if it saved, it will return true.
		printf("\n>>>Saved successfully! \n\n");

		else
		printf("ERROR: Could not save to file.\n\n");

	} // end else

	return 0;
} // end main




// ######################################################
// READ_SAVE // THIS FUNCTION READS THE FILE CONTENTS

//Now this is the function that reads the file.
// Pass it a struct and it will fill it up with the variables.
//I preffer classes but they are too long to write here.

bool read_save(tagSAVE & sav){

FILE *fp;				// file pointer, always used when messing with files
int i = 0;				// general purpose
char line[50]={0};		// this array will hold the currenlt line been scanned
char variables[3][50];	// this will hold the variables while reading
						// the 3 is the amount of variables(name, level, boss = 3)
						// 50 is their lengths name[50]

	// open file
	if((fp = fopen("c:\\foo.txt", "r")) == NULL){
		printf(">Didn't find foo.txt\n");

		// If the file didn't open(probably there is no file)
		// return bad.
		return false;
	}


	// if you got to this point, the file was read successfully
	while(fgets(line, 50, fp)){ // fgets() gets contents line by line
								// param 1 = char array, param 2 =
								// maximun # of bytes, param 3 = file pointer 

    // for each iteration copy the contents of the line to a variable
	strcpy(variables[i], line);

	// increase this so that we could point to our next variable
	i++;
	}


	// after the while loop is finished, copy the contents to the struct 
	strcpy(sav.name,variables[0]);
	strcpy(sav.level,variables[1]);
	strcpy(sav.boss,variables[2]);

// don't forget to close the file
fclose(fp);

// return good
return true;
}





// #######################################################################
// save function
// #######################################################################
bool save( tagSAVE & sav){

// create a file pointer
FILE *fp; 

// open file for writing. if your're using linux, subtitute the file  path
if((fp = fopen("c:\\foo.txt", "w")) == NULL){

printf("\n\nERROR: could not open file. \n"); 

// if you could open the file, you either don't have write permission or
// there was a major error. If this happens, you can't really do anything.
return false;
}

// This puts the string pointed to by name to the previously opened file.
// check how the function is fprintf(), not printf()
fprintf(fp, "%s\n", sav.name); 

// put the other variable
fprintf(fp, "%s\n", sav.level); 

// we can put lots of info if we wanted
fprintf(fp, "%s\n", sav.boss);

// don't forget to close the file
fclose(fp);

// return good.
return true;

}

#include <memory.h>
#include <string.h>
#include <stdio.h>

struct Player {
	char name[50];
	int age;
	char sex;
};

// forward declares for functions
void save(char* file, void* item, int size);
void load(char* file, void* item, int size);

int main(int argc, char* argv[]) {
	// declare and initialize a player object
	Player pl;
	pl.age = 25;
	strcpy(pl.name, "Bob");
	pl.sex = 'M';
	
	// save the player structure
	save("c:\\player.dat", &pl, sizeof(Player));
	// clear the player structure for testing purposes
	memset(&pl, 0, sizeof(pl));
	
	// load the data back into the player structure
	load("c:\\player.dat", &pl, sizeof(Player));

	return 0;
}

// saves the structure or class into <file>
void save(char* file, void* item, int size) {
	FILE *fp;

	// open a file for binary writing
	fp = fopen(file, "wb");

	// validate the file pointer
	if (fp == NULL) {
		printf("Could not open %s for writing.\n", file);
		return;
	}

	// write the structure or class to the file
	fwrite(item, size, 1, fp);

	// be a good citizen and clean up after yourself
	fclose(fp);

	return;
}

// reads the structure from  <file>
void load(char* file, void* item, int size) {
	FILE *fp;

	// open the file for binary writing
	fp = fopen(file, "rb");

	// validate the file pointer
	if(fp == NULL) {
		printf("Could not open file %s for reading.", file);
		return;
	}
	
	// read the data back into the structure
	fread(item, size, 1, fp);

	// make sure to clean up after yourself
	fclose(fp);

	return;

}

#include <stdio.h> // for printf
#include <string.h> // for string functions

// prototype
void print_stuff(char *); // see, the function takes a pointer as an argument

int main(){

// make array that will hold the message
char happy_array[100];

// put something in the array
strcpy(happy_array, "I am so happy, the world is beautiful.");

// call the function
print_stuff(happy_array);

// other lines of code if you want

return 0;

}

void print_stuff(char * stuff){

printf("%s \n", stuff);

}