未定义的标识符和标识符未定义是什么意思？如何解决这个错误？

#include "stdafx.h" 
#include <stdio.h> 
#include <conio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <iostream> 

using namespace std; 

#define TIMEQUANTUM 1; 
#define MAXPROCTIME 100; 


struct SortList 
{ 
    int pid; 
    int arrivalTime; 
    int burstTime; 
    SortList *nxt; 
}; 

struct JobList { 
    int pid; 
    int ct_arrival; 
    int ct_service; 
    int vt_served; 
    int vt_residence; 
    int vt_wait; 
    int vt_completion; 
    JobList *nxt; 
}; 



bool initJobList(JobList *&,int *,int); 
bool deinit(JobList *&); 
bool doFCFS (JobList *&); 
bool doRR (JobList *&); 
bool doSJF(JobList *&, SortList *&); 
bool doNPSJF (JobList *&); 
bool doPSJF (JobList *&); 
bool sortJob (JobList *&, SortList *&); 

int _tmain(int argc, _TCHAR* argv[]) 
{ 

    JobList *ptrJobStart; 
    // arrivaltime , bursttime 
    int arrJobs[][2] = { 
         {0,7}, 
         {2,4}, 
         {4,1}, 
         {5,4} 
    }; 
    SortList *ptrList; 
    initJobList (ptrJobStart,(int *)&arrJobs, (sizeof(arrJobs)/(sizeof(int)*2))); 
    printf("\ndoFCFS\nCPU\t\tPROCESS\n"); 
     doFCFS (ptrJobStart); 
    deinit(ptrJobStart); 

    initJobList (ptrJobStart,(int *)&arrJobs, (sizeof(arrJobs)/(sizeof(int)*2))); 
    printf("\n\ndoSJF\nCPU\t\tPROCESS\n"); 
     doSJF(ptrJobStart, ptrList); 
    deinit(ptrJobStart); 


    initJobList (ptrJobStart,(int *)&arrJobs, (sizeof(arrJobs)/(sizeof(int)*2))); 
    printf("\ndoRR\nCPU\t\tPROCESS\n"); 
    doRR(ptrJobStart); 
    deinit(ptrJobStart); 

    initJobList (ptrJobStart,(int *)&arrJobs, (sizeof(arrJobs)/(sizeof(int)*2))); 
    printf("\ndoPSJF\nCPU\t\tPROCESS\n"); 
    doRR(ptrJobStart); 
    deinit(ptrJobStart); 

    getch(); 
    return 0; 
} 

bool doRR(JobList *&ptrJobStart) 
{ 


    if(ptrJob==NULL) return false; 
    JobList *ptrJobStart, *tempJobList; 
    ptrJobStart = ptrJob; 
    int maxTime = MAXPROCTIME; 
    int timeQuantum = TIMEQUANTUM; 
    bool flag = false; 
    ptrJobStart->vt_served = 0; 
    for(int processTime = 0; (processTime < maxTime) && !flag ;) 
    { 
     //check if all jobs are finished 
     flag = true; 
     tempJobList = ptrJob; 
     while(tempJobList!=NULL) 
     { 
      if(tempJobList->vt_served!=tempJobList->ct_service) 
      { 
       flag = false; 
      } 
      tempJobList = tempJobList->nxt; 
     } 
    } 
    //logic 
    return true; 
} 

bool doSJF(JobList *&ptrJobStart, SortList *&ptrList) 
{ 
    if(ptrJobStart==NULL) return false; 
    sortJob(ptrJobStart, ptrList); 
    doFCFS (ptrJobStart); 
    return true; 
} 

bool sortJob (JobList *&ptrJob, SortList *&ptrList) 
{ 
    JobList *ptrJobStart = ptrJob; 
    if(ptrJobStart==NULL) return false; 
    int maxTime = MAXPROCTIME; 
    SortList *newList; 
    ptrList = NULL; 
    for(; ptrJobStart!=NULL; ptrJobStart = ptrJobStart->nxt) // accumulate all arrival time = 0 
    { 
     if(ptrJobStart->ct_arrival==0) 
     { 
      if(ptrList==NULL) 
      { 
       ptrList = new SortList; 
       ptrList->pid = ptrJobStart->pid; 
       ptrList->arrivalTime = ptrJobStart->ct_arrival; 
       ptrList->burstTime = ptrJobStart->ct_service; 
       ptrList->nxt = NULL; 
      } 
      else 
      { 
       newList = new SortList; 
       newList->pid = ptrJobStart->pid; 
       newList->arrivalTime = ptrJobStart->ct_arrival; 
       newList->burstTime = ptrJobStart->ct_service; 
       newList->nxt = NULL; 
       ptrList->nxt = newList; 
      } 
     } 
    } 
    SortList *tempList; 
    tempList = ptrList; 
    for(int processTime = 1 ; processTime < maxTime ; processTime++) // accumulate all burst time from 1 to 100 
    { 
     ptrJobStart = ptrJob; 
     do 
     { 
      if((ptrJobStart->ct_arrival!=0) && (processTime == ptrJobStart->ct_service)) 
      { 
       newList = new SortList; 
       newList->pid = ptrJobStart->pid; 
       newList->arrivalTime = ptrJobStart->ct_arrival; 
       newList->burstTime = ptrJobStart->ct_service; 
       newList->nxt = NULL; 
       tempList->nxt = newList; 
       tempList = tempList->nxt; 
      } 
      ptrJobStart = ptrJobStart->nxt; 
     }while(ptrJobStart!=NULL); 
    } 
    //sort jobs 
    ptrJobStart = ptrJob; 
    JobList *tempJobList; 
    tempJobList = ptrJobStart; 
    for(; ptrList!=NULL; ptrList = ptrList->nxt) 
    { 
     tempJobList->pid = ptrList->pid; 
     tempJobList->ct_arrival = ptrList->arrivalTime; 
     tempJobList->ct_service = ptrList->burstTime; 
     tempJobList = tempJobList->nxt; 
    } 
    return true; 
} 


bool doFCFS (JobList *& ptrJob) 
{ 
    JobList *ptrJobStart = ptrJob; 
    if(ptrJobStart==NULL) return false; 
    int maxTime = MAXPROCTIME; 
    ptrJobStart->vt_served = 0; 
    for(int processTime = 0; processTime < maxTime; processTime++) 
    { 
     if(ptrJobStart->vt_served!=ptrJobStart->ct_service) 
     { 
      ptrJobStart->vt_served+=1; 
     } 
     else 
     { 
      ptrJobStart->vt_completion = processTime; 
      ptrJobStart->vt_residence = processTime - ptrJobStart->ct_arrival; 
      ptrJobStart->vt_wait = processTime - ptrJobStart->vt_served; 
      cout<<"\n/* vt_served:"<<ptrJobStart->vt_served<<"\tvt_residence:"<<ptrJobStart->vt_residence 
       <<"\tvt_wait:"<<ptrJobStart->vt_wait<<"\tvt_completion:"<<ptrJobStart->vt_completion<<" */"; 
      ptrJobStart = ptrJobStart->nxt; 
      if(ptrJobStart==NULL) break; 
      else 
       ptrJobStart->vt_served = 1; 
     } 
     cout<<"\n "<<processTime<<"\t>>\t P"<<ptrJobStart->pid; 
    } 
    return true; 
} 


bool deinit (JobList *& ptrJobStart) { 

    JobList *ptrJobDel = NULL; 
    do { 

     ptrJobDel = ptrJobStart; 
     ptrJobStart = ptrJobStart->nxt; 
     delete ptrJobDel; 
    }while (ptrJobStart != NULL); 
    return true; 
} 


bool initJobList(JobList*& ptrJobStart,int *pJob,int nJobs){ 

    JobList * ptrJobs = NULL; 
    int i; 
    int j=1; 

    for (i=0; i<nJobs*2; i+=2) { 
     if (ptrJobs == NULL) { 
      ptrJobs = new JobList; 
      memset(ptrJobs,0,sizeof(JobList)); 
      ptrJobStart = ptrJobs; 
     } 
     else { 
      ptrJobs->nxt = new JobList; 
      memset(ptrJobs->nxt,0,sizeof(JobList)); 
      ptrJobs = ptrJobs->nxt; 
     } 
     ptrJobs->ct_arrival = *(pJob+i); 
     ptrJobs->ct_service = *(pJob+(i+1)); 
     ptrJobs->pid = j; 
     ptrJobs->nxt = NULL; 
     j++; 
    } 
    return true;

此代码用于调度算法。最短的Job Next（SJN）/最短的Job First（SJF）（这是doSJN）正在工作。但是当我包含doRR（循环）时，发生了很多错误。未定义的标识符和标识符未定义是什么意思？如何解决这个错误？

错误C2065：ptrJob'：未声明的标识符错误C2082：形式参数的重新定义“ptrJobStart 错误C2065：ptrJob'：未声明的标识符错误C2065：ptrJob'：未声明的标识符看到的声明 '的getch'

我该如何解决这个问题？

来源

2013-02-28 Celyn Marasigan

你知道术语“标识符”和“声明”是什么意思吗？你能在代码中发现两者的实例吗？ – 2013-02-28 17:02:55

在doRR中，参数名称为ptrJobStart。应该是ptrJob。

您得到的错误表明，在doRR的第一行上，ptrJob尚未声明。

来源

2013-02-28 17:01:01 cedrou

谢谢。这有助于。但另一件事，没有输出。 doRR的输出是空白的。这是为什么？ – 2013-02-28 17:18:34

“输出为空”是什么意思？ – cedrou 2013-02-28 17:21:03

每个进程的输出必须包括进程和完成的作业数量。与doRR的部分不同，它不给任何东西。 – 2013-02-28 18:17:42

的第一个错误（形式参数“ptrJobStar”的重新定义）发生在这里：

bool doRR(JobList *&ptrJobStart) 
{ 


    if(ptrJob==NULL) return false; 
    JobList *ptrJobStart, *tempJobList;

你定义的参数ptrJobStart，然后宣布在代码中的同名参数。

我相信第二个错误（'ptrJob：未声明的标识符）发生在这里：

bool doRR(JobList *&ptrJobStart) 
{ 


    if(ptrJob==NULL) return false;

这是因为 'ptrJob' 似乎并不被内多尔宣布（）。

希望有所帮助。

来源

2013-02-28 17:02:53

是的。谢谢。 – 2013-02-28 18:14:08

是的。但我有另一个问题。如果我可以在这里发布我的输出的截图。 – 2013-02-28 18:16:50

http://www.mediafire.com/view/?u1s72x2d81jp4ms屏幕截图 – 2013-02-28 18:27:14

未定义的标识符和标识符未定义是什么意思？如何解决这个错误？

回答

相关问题