Error c2144 syntax error void should be preceded by

Hi guys,

i have a small question. I have my project and I have I90ControllerDlg.cpp.This is you can say my main. I have another .cpp file called multipoletutorial.cpp that I added to my project tree. I already compile it and everything is ok, so it is compiling the multipoletutorial.cpp file. Now in this file I have a function void cica (void). I tried to call this function in my main program, after I declare it at the begining. When calling it, I set a breackpoint so I can go inside to see what is happening …but it seems that the program when debuging it «changes» automatically the position of the  breackpoint to the next line. So I can never go inside.

I will post  multipoletutorila.cpp file.

In my main file I wrote like this at the begining of the program

using namespace std;
void cica(void);
So I declared it.

and then I tried to call it
cica ();
or cica(void);
and it gives me error
 error C2144: syntax error : ‘void’ should be preceded by ‘)’

So it does not recognize it?

I made another .cpp file and I had a function there and when calling it , it works, but this new one seems not to work.
Please give me a solution.

// Copyright (C) 2003
// Gerhard Neumann (gneumann@gmx.net)
// Stephan Neumann (sneumann@gmx.net) 
//                
// This file is part of RL Toolbox.
// http://www.igi.tugraz.at/ril_toolbox
//
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
/*****************************************************************************************************
Tutorial for the Reinforcement Learning Toolbox. In this example the Pole Balancing task is learned with
a Q-Learning algorithm. For discretization build-in single state discretizer are used. 
The task is learned until the agent manages to pole the cart for over 100000 steps or for 500 episodes.
******************************************************************************************************/
#include "stdafx.h"
#include <time.h>
#include "ril_debug.h"
//#include "cmultipolemodel.h"
#include "robotlearning.h"
//#include "robotlearning.cpp"
#include "ctdlearner.h"
#include "cpolicies.h"
#include "cagent.h"
 
#define one_degree 0.0174532	/* 2pi/360 */
#define six_degrees 0.1047192
#define twelve_degrees 0.2094384
#define fifty_degrees 0.87266
//#define degree 60
//#define time 1000
//#define myforce 0
 
CMultiPoleAction mywrapper(rlt_real myforce,double degree, short time1)
{
	CEnvironmentModel *model1 = NULL;
	CAgentStatisticController *detController1 = NULL;
	CAbstractStateDiscretizer *discState1 = NULL;
	CRewardFunction *rewardFunction1 = NULL;
	CAgent *agent1;
 
 
   CMultiPoleAction myaction(myforce);
	//CMultiPoleAction1 myaction();
 
    //time = xxxx;
     myaction.TurnDegree(degree, time1);
     
     
    
     return myaction;
}
 
void cica(void)
{
	 rlt_real myforce;  
	double degree;
	short time1;
	
 CMultiPoleAction myact; 
  myact = mywrapper(19,60,100);
 
	// initialize the random generator
	srand((unsigned int)time((time_t *)NULL));
 
	// variable declaration
	CEnvironmentModel *model = NULL;
	CAgentStatisticController *detController = NULL;
	CAbstractStateDiscretizer *discState = NULL;
	CRewardFunction *rewardFunction = NULL;
	CAgent *agent;
 
	// create the discretizer with the build in classes
	// create the partition arrays
	double partitions1[] = {-0.8, 0.8}; // partition for x
	double partitions2[] = {-0.5, 0.5}; // partition for x_dot
	double partitions3[] = {-six_degrees, -one_degree, 0, one_degree, six_degrees}; // partition for theta
	double partitions4[] = {-fifty_degrees, fifty_degrees}; // partition for theta_dot
	double partitions5[] = {-fifty_degrees, fifty_degrees}; // partition for theta_dot
 
	// Create the discretizer for the state variables
	CAbstractStateDiscretizer *disc1 = new CSingleStateDiscretizer(0, 2, partitions1);
	CAbstractStateDiscretizer *disc2 = new CSingleStateDiscretizer(1, 2, partitions2);
	CAbstractStateDiscretizer *disc3 = new CSingleStateDiscretizer(2, 7, partitions3);
	CAbstractStateDiscretizer *disc4 = new CSingleStateDiscretizer(3, 2, partitions4);
 
	// Merge the 4 discretizer
	CDiscreteStateOperatorAnd *andCalculator = new CDiscreteStateOperatorAnd();
 
	andCalculator->addStateModifier(disc1);
	andCalculator->addStateModifier(disc2);
	andCalculator->addStateModifier(disc3);
	andCalculator->addStateModifier(disc4);
 
	// Create the failed state discretizer, which distinguishes the state in "failed" and "not failed"
	discState = new CMultiPoleFailedState();
	discState->addStateSubstitution(1, andCalculator);
 
	// create the model
	//model = new CMultiPoleModel(discState);
	model = new CMultiPoleModel();
	// iniialise the reward function
	/* reward function and model are merged*/
	rewardFunction = (CMultiPoleModel *)model;
 
	// create the agent
	agent = new CAgent(model); 
	
	// create the 2 actions for accelearting the cart and add them to the agent's action set
	//CPrimitiveAction *primAction1 = new CMultiPoleAction(10.0, discState);
	//CPrimitiveAction *primAction2 = new CMultiPoleAction(-10.0, discState);
	CPrimitiveAction *primAction1 = new CMultiPoleAction(10.0);
	CPrimitiveAction *primAction2 = new CMultiPoleAction(-10.0);
 
	agent->addAction(primAction1);
	agent->addAction(primAction2);
 
	// create the discrete state with the self-coded class
	/* not used
	discState = new CMultiPoleDiscreteState();
	*/
 
	// add the discrete state to the agent's state modifier
	// discState must not be modified (e.g. with a State-Substitution) by now
	agent->addStateModifier(discState);
 
	// Create the learner and the Q-Function
	CFeatureQFunction *qTable = new CFeatureQFunction(agent->getActions(), discState);
	CTDLearner *learner = new CQLearner(rewardFunction, qTable);
	// initialise the learning algorithm parameters
	learner->setAlpha(0.1);
	//learner->getQFunction()->setGamma(0.95);
	learner->getETraces()->setReplacingETraces(true);
	learner->getETraces()->setLambda(0.9);
 
	// add the Q-Learner to the listener list
	agent->addSemiMDPListener(learner);
 
	// Create the learners controller
	CAgentStatisticController *policy = NULL;
	policy = new CQGreedyPolicy(agent->getActions(), qTable);
	// set the policy as controller of the agent
	agent->setController(policy);
	
	// disable automatic logging of the episode from the agent
	agent->setLogEpisode(false);
 
	int steps = 0;
 
	// Learn for 500 Episodes
	for (int i = 0; i < 500 && steps < 100000; i++)
	{
		// Do one training trial, with max 100000 steps
		steps = agent->doControllerEpisode(1, 100000);
 
		printf("Episode %d %s with %d stepsn", i, model->isFailed() ? "failed" : "succeded", steps);
		
	}
 
 
	delete policy;
	delete learner;
	delete agent;
	delete qTable;
	delete model;
	
	printf("nn<< Press Enter >>n");
	getchar();
};

Open in new window