Can you call a function from inside a class function?

[nixadD]

Good morning everyone.
Have a question about calling one of my dice roll functions from inside a class i have made.
Is this possible to do with C++?

I'm getting identifier not found errors. for d10Roll()

Is there a different way i need to go about this?

void TheDarklake::getCollision() {

	int d10a = d10Roll();
	int d10b = d10Roll();
	int d10c = d10Roll();

	std::cout << "------------------------------ Collision -----------------------------" << std::endl;
	std::cout << "This terrain encounter occurs only if one or more party members are " << std::endl;
	std::cout << "traveling by raft or boat, and there's a strong current. Have everyone" << std::endl;
}  

[Phil15]

if d10Roll is within the class, you may have forgotten to specify the function in the header

class TheDarklake
{
void getCollision();
void d10Roll();

}

Or you might have forgotten the implementation of that function

TheDarklake::d10Roll()
{
   //Roll Code
}
TheDarklake::getCollision()
{
// collision code


}

also make sure you have specified the d10Roll above the getCollision

Hope that helps

[nixadD]

Ok i understand now.
So, I'd have to create a d10Roll(); function in every class I create that uses a dice roll?
I can't use the random dice functions I already have in my main source.cpp file?

[Phil15]

You can write the implementation of d10Roll in TheDarkLake or whichever class you prefer and then include the header of that class into another class

so if you have source.cpp

#include "TheDarklake.h"


int main()
{
 TheDarklake darklake;
darklake.d10Roll();

}

if you dont like that approach you can do something called forward declaration.
Given that the class which called TheDarklake class will have the d10Roll() implementation you can do something like this

source.cpp

#include <iostream>
#include "TheDarkLake.h"


void d10Roll()
{

	std::cout << "calling roll" << std::endl;
}


int main()
{
	TheDarkLake dk;


	system("pause");
	

}

TheDarkLake.cpp

#include "TheDarkLake.h"

void d10Roll(); // forward declaration here promising the compiler that this function indeed exists later in the code.

TheDarkLake::TheDarkLake()
{
	d10Roll();

}


TheDarkLake::~TheDarkLake()
{
}

[nixadD]

Still don't think i'm going about it corectly.
What do you think about this code example?

source.cpp

#include <iostream>
#include <cstdlib>
#include <ctime>

int d6Roll();
int d10Roll();

int main() {

	srand((unsigned)time(NULL));

        TheDarklake darklake;
	darklake.d10Roll();

        darklakeTerrainEncounters();

        system("PAUSE");
	return 0;
}

int d6Roll() {
	int d6_result;

	d6_result = rand() % 6 + 1;

	return d6_result;
}

int d10Roll() {
	int d10_result;

	d10_result = rand() % 10 + 1;

	return d10_result;
}


void darklakeTerrainEncounters() {

	int d6 = d6Roll();

	std::cout << "--------------------- Darklake Terrain Encounter ---------------------" << std::endl;
	std::cout << "Darklake Terrain Encounter Roll = " << d10 << std::endl;

	if (d6 == 1) {
		//Collision
		darklake.getCollision();
		std::cout << std::endl;
	}
}

        

TheDarklake.h

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>

#ifndef TheDarklake_H
#define TheDarklake_H



class TheDarklake {
public:

	TheDarklake();
	~TheDarklake();

	int d10Roll();

	// The Darklake Terrain Encounters
	void getCollision();

private:

}

TheDarklake.cpp

#include "TheDarklake.h"


TheDarklake::TheDarklake() {

	d10Roll();
}

TheDarklake::~TheDarklake() {}


// The Darklake Terrain Encounters
void TheDarklake::getCollision() {

	int d10a = d10Roll();
	int d10b = d10Roll();
	int d10c = d10Roll();

	std::cout << "------------------------------ Collision -----------------------------" << std::endl;
	std::cout << "Collision Damage is "<< d10a + d10b + d10c << std::endl;
        std::cout << std::endl;
}