未申報的標識符？

Question

保持收到錯誤的代碼，它是一個從舊到VS 2010版的轉換：

#include <string> 
#include <stdlib.h> 
#include <iostream> 
#include <time.h> 
#include <math.h> 

using std::string; 

#define CROSSOVER_RATE   0.7 
#define MUTATION_RATE    0.001 
#define POP_SIZE     100   //must be an even number 
#define CHROMO_LENGTH    300 
#define GENE_LENGTH    4 
#define MAX_ALLOWABLE_GENERATIONS 400 

//returns a float between 0 & 1 
#define RANDOM_NUM  ((float)rand()/(RAND_MAX+1)) 

//---------------------------------------------------------------------------------------- 
// 
// define a data structure which will define a chromosome 
// 
//---------------------------------------------------------------------------------------- 
struct chromo_typ 
{ 
    //the binary bit string is held in a std::string 
    string bits; 

    float  fitness; 

    chromo_typ(): bits(""), fitness(0.0f){}; 
    chromo_typ(string bts, float ftns): bits(bts), fitness(ftns){} 
}; 


/////////////////////////////////prototypes///////////////////////////////////////////////////// 

void PrintGeneSymbol(int val); 
string GetRandomBits(int length); 
int  BinToDec(string bits); 
float AssignFitness(string bits, int target_value); 
void PrintChromo(string bits); 
void PrintGeneSymbol(int val); 
int  ParseBits(string bits, int* buffer); 
string Roulette(int total_fitness, chromo_typ* Population); 
void Mutate(string &bits); 
void Crossover(string &offspring1, string &offspring2); 



//-------------------------------main-------------------------------------------------- 
// 
//------------------------------------------------------------------------------------- 
int main() 
{ 
    //seed the random number generator 
    srand((int)time(NULL)); 

    //just loop endlessly until user gets bored :0) 
    while (true) 
    { 
    //storage for our population of chromosomes. 
    chromo_typ Population[POP_SIZE]; 

     //get a target number from the user. (no error checking) 
     float Target; 
     cout << "\nInput a target number: "; 
     cin >> Target; 
    cout << endl << endl; 

     //first create a random population, all with zero fitness. 
     for (int i=0; i<POP_SIZE; i++) 
     { 
      Population[i].bits  = GetRandomBits(CHROMO_LENGTH); 
      Population[i].fitness = 0.0f; 
     } 

     int GenerationsRequiredToFindASolution = 0; 

     //we will set this flag if a solution has been found 
     bool bFound = false; 

     //enter the main GA loop 
     while(!bFound) 
     { 
      //this is used during roulette wheel sampling 
      float TotalFitness = 0.0f; 

      // test and update the fitness of every chromosome in the 
     // population 
      for (int i=0; i<POP_SIZE; i++) 
      { 
       Population[i].fitness = AssignFitness(Population[i].bits, Target); 

       TotalFitness += Population[i].fitness; 
      } 

      // check to see if we have found any solutions (fitness will be 999) 
      for (i=0; i<POP_SIZE; i++) 
      { 
       if (Population[i].fitness == 999.0f) 
       { 
      cout << "\nSolution found in " << GenerationsRequiredToFindASolution << " generations!" << endl << endl;; 

        PrintChromo(Population[i].bits); 

        bFound = true; 

      break; 
       } 
      } 

      // create a new population by selecting two parents at a time and creating offspring 
     // by applying crossover and mutation. Do this until the desired number of offspring 
     // have been created. 

      //define some temporary storage for the new population we are about to create 
      chromo_typ temp[POP_SIZE]; 

      int cPop = 0; 

      //loop until we have created POP_SIZE new chromosomes 
      while (cPop < POP_SIZE) 
      { 
       // we are going to create the new population by grabbing members of the old population 
       // two at a time via roulette wheel selection. 
       string offspring1 = Roulette(TotalFitness, Population); 
       string offspring2 = Roulette(TotalFitness, Population); 

     //add crossover dependent on the crossover rate 
     Crossover(offspring1, offspring2); 

       //now mutate dependent on the mutation rate 
       Mutate(offspring1); 
       Mutate(offspring2); 

       //add these offspring to the new population. (assigning zero as their 
     //fitness scores) 
       temp[cPop++] = chromo_typ(offspring1, 0.0f); 
       temp[cPop++] = chromo_typ(offspring2, 0.0f); 

      }//end loop 

      //copy temp population into main population array 
      for (i=0; i<POP_SIZE; i++) 
     { 
       Population[i] = temp[i]; 
     } 

      ++GenerationsRequiredToFindASolution; 

      // exit app if no solution found within the maximum allowable number 
      // of generations 
      if (GenerationsRequiredToFindASolution > MAX_ALLOWABLE_GENERATIONS) 
      { 
       cout << "No solutions found this run!"; 

       bFound = true; 
      } 

     } 

    cout << "\n\n\n"; 

    }//end while 

    return 0; 
} 




//---------------------------------GetRandomBits----------------------------------------- 
// 
// This function returns a string of random 1s and 0s of the desired length. 
// 
//----------------------------------------------------------------------------------------- 
string GetRandomBits(int length) 
{ 
    string bits; 

    for (int i=0; i<length; i++) 
    { 
     if (RANDOM_NUM > 0.5f) 

      bits += "1"; 

     else 

      bits += "0"; 
    } 

    return bits; 
} 

//---------------------------------BinToDec----------------------------------------- 
// 
// converts a binary string into a decimal integer 
// 
//----------------------------------------------------------------------------------- 
int BinToDec(string bits) 
{ 
    int val   = 0; 
    int value_to_add = 1; 

    for (int i = bits.length(); i > 0; i--) 
    { 


     if (bits.at(i-1) == '1') 

      val += value_to_add; 

     value_to_add *= 2; 

    }//next bit 

    return val; 
} 


//---------------------------------ParseBits------------------------------------------ 
// 
// Given a chromosome this function will step through the genes one at a time and insert 
// the decimal values of each gene (which follow the operator -> number -> operator rule) 
// into a buffer. Returns the number of elements in the buffer. 
//------------------------------------------------------------------------------------ 
int ParseBits(string bits, int* buffer) 
{ 

    //counter for buffer position 
    int cBuff = 0; 

    // step through bits a gene at a time until end and store decimal values 
    // of valid operators and numbers. Don't forget we are looking for operator - 
    // number - operator - number and so on... We ignore the unused genes 1111 
    // and 1110 

    //flag to determine if we are looking for an operator or a number 
    bool bOperator = true; 

    //storage for decimal value of currently tested gene 
    int this_gene = 0; 

    for (int i=0; i<CHROMO_LENGTH; i+=GENE_LENGTH) 
    { 
     //convert the current gene to decimal 
     this_gene = BinToDec(bits.substr(i, GENE_LENGTH)); 

     //find a gene which represents an operator 
     if (bOperator) 
     { 
      if ((this_gene < 10) || (this_gene > 13)) 

       continue; 

      else 
      { 
       bOperator  = false; 
       buffer[cBuff++] = this_gene; 
       continue; 
      } 
     } 

     //find a gene which represents a number 
     else 
     { 
      if (this_gene > 9) 

       continue; 

      else 
      { 
       bOperator  = true; 
       buffer[cBuff++] = this_gene; 
       continue; 
      } 
     } 

    }//next gene 

    // now we have to run through buffer to see if a possible divide by zero 
    // is included and delete it. (ie a '/' followed by a '0'). We take an easy 
    // way out here and just change the '/' to a '+'. This will not effect the 
    // evolution of the solution 
    for (i=0; i<cBuff; i++) 
    { 
     if ((buffer[i] == 13) && (buffer[i+1] == 0)) 

      buffer[i] = 10; 
    } 

    return cBuff; 
} 

//---------------------------------AssignFitness-------------------------------------- 
// 
// given a string of bits and a target value this function will calculate its 
// representation and return a fitness score accordingly 
//------------------------------------------------------------------------------------ 
float AssignFitness(string bits, int target_value) 
{ 

    //holds decimal values of gene sequence 
    int buffer[(int)(CHROMO_LENGTH/GENE_LENGTH)]; 

    int num_elements = ParseBits(bits, buffer); 

    // ok, we have a buffer filled with valid values of: operator - number - operator - number.. 
    // now we calculate what this represents. 
    float result = 0.0f; 

    for (int i=0; i < num_elements-1; i+=2) 
    { 
     switch (buffer[i]) 
     { 
      case 10: 

       result += buffer[i+1]; 
       break; 

      case 11: 

       result -= buffer[i+1]; 
       break; 

      case 12: 

       result *= buffer[i+1]; 
       break; 

      case 13: 

       result /= buffer[i+1]; 
       break; 

     }//end switch 

    } 

    // Now we calculate the fitness. First check to see if a solution has been found 
    // and assign an arbitarily high fitness score if this is so. 

    if (result == (float)target_value) 

     return 999.0f; 

    else 

     return 1/(float)fabs((double)(target_value - result)); 
    // return result; 
} 

//---------------------------------PrintChromo--------------------------------------- 
// 
// decodes and prints a chromo to screen 
//----------------------------------------------------------------------------------- 
void PrintChromo(string bits) 
{ 
    //holds decimal values of gene sequence 
    int buffer[(int)(CHROMO_LENGTH/GENE_LENGTH)]; 

    //parse the bit string 
    int num_elements = ParseBits(bits, buffer); 

    for (int i=0; i<num_elements; i++) 
    { 
     PrintGeneSymbol(buffer[i]); 
    } 

    return; 
} 

//--------------------------------------PrintGeneSymbol----------------------------- 
// 
// given an integer this function outputs its symbol to the screen 
//---------------------------------------------------------------------------------- 
void PrintGeneSymbol(int val) 
{ 
    if (val < 10) 

     cout << val << " "; 

    else 
    { 
     switch (val) 
     { 

     case 10: 

      cout << "+"; 
      break; 

     case 11: 

      cout << "-"; 
      break; 

     case 12: 

      cout << "*"; 
      break; 

     case 13: 

      cout << "/"; 
      break; 

     }//end switch 

     cout << " "; 
    } 

    return; 
} 

//------------------------------------Mutate--------------------------------------- 
// 
// Mutates a chromosome's bits dependent on the MUTATION_RATE 
//------------------------------------------------------------------------------------- 
void Mutate(string &bits) 
{ 
    for (int i=0; i<bits.length(); i++) 
    { 
     if (RANDOM_NUM < MUTATION_RATE) 
     { 
      if (bits.at(i) == '1') 

       bits.at(i) = '0'; 

      else 

       bits.at(i) = '1'; 
     } 
    } 

    return; 
} 

//---------------------------------- Crossover --------------------------------------- 
// 
// Dependent on the CROSSOVER_RATE this function selects a random point along the 
// lenghth of the chromosomes and swaps all the bits after that point. 
//------------------------------------------------------------------------------------ 
void Crossover(string &offspring1, string &offspring2) 
{ 
    //dependent on the crossover rate 
    if (RANDOM_NUM < CROSSOVER_RATE) 
    { 
    //create a random crossover point 
    int crossover = (int) (RANDOM_NUM * CHROMO_LENGTH); 

    string t1 = offspring1.substr(0, crossover) + offspring2.substr(crossover, CHROMO_LENGTH); 
    string t2 = offspring2.substr(0, crossover) + offspring1.substr(crossover, CHROMO_LENGTH); 

    offspring1 = t1; offspring2 = t2;     
    } 
} 


//--------------------------------Roulette------------------------------------------- 
// 
// selects a chromosome from the population via roulette wheel selection 
//------------------------------------------------------------------------------------ 
string Roulette(int total_fitness, chromo_typ* Population) 
{ 
    //generate a random number between 0 & total fitness count 
    float Slice = (float)(RANDOM_NUM * total_fitness); 

    //go through the chromosones adding up the fitness so far 
    float FitnessSoFar = 0.0f; 

    for (int i=0; i<POP_SIZE; i++) 
    { 
     FitnessSoFar += Population[i].fitness; 

     //if the fitness so far > random number return the chromo at this point 
     if (FitnessSoFar >= Slice) 

      return Population[i].bits; 
    } 

    return ""; 
} 

的錯誤，我得到的是：

error C2065: 'cin' : undeclared identifier 
error C2065: 'cout' : undeclared identifier 
error C2065: 'endl' : undeclared identifier 
error C2065: 'i' : undeclared identifier 
error C2228: left of '.bits' must have class/struct/union 
error C2228: left of '.fitness' must have class/struct/union 

Answer 1

前綴每cin, cout（給std :: cin， std :: cout）與std或在開頭聲明using namespace std;。

// check to see if we have found any solutions (fitness will be 999) 
for (i=0; i<POP_SIZE; i++) 

//copy temp population into main population array 
for (i=0; i<POP_SIZE; i++) // In both cases, You forgot to declare i. So, change to 
          // for (int i=0; ...) 

Answer 2

要麼你想std::cin（等），或在using std::cin;源文件的頂部。

至於i;好了，你有一個使用i未聲明的一個循環（這反過來也與.bits和.fitness導致的問題。

Answer 3

error C2065: 'cin' : undeclared identifier 
error C2065: 'cout' : undeclared identifier 
error C2065: 'endl' : undeclared identifier 

無論前綴每次使用的cin，cout，並且endl與std::，或添加這些行到你的程序的包括後：

using std::cout; 
using std::cin; 
using std::endl; 

至於接下來的錯誤：

error C2065: 'i' : undeclared identifier 

改變這一行：

for (i=0; i<POP_SIZE; i++) 

這樣：

for (int i = 0; i < POP_SIZE; i++) 

循環變量聲明走出去的範圍在循環的結束。

P.s.優選cout << '\n'至cout << endl。後者刷新輸出流（通常是不必要的），如果你正在向文件寫入很多行，會產生可怕的減速。