Ошибка expected at end of input

I have moved from Java to CPP and am struggling to wrap my head around structuring constructor chaining, which I think is the sourceof my issues.

My header file is as follows:

public:
GuidedTour();
GuidedTour(string ID, string desc, double fee, int size, string guide, string date)
            : Tour(ID, desc, fee);

And my cpp file is as follows:

 GuidedTour(string ID, string desc, double fee, int size, string guide, string date)
            : Tour(ID, desc, fee) {
                this->tourSize = size;
                this ->tourGuide = guide;
                this -> tourDate = date;
                }

I am getting two errors:

guided_tour.h: In constructor 'GuidedTour::GuidedTour(std::string, std::string, double, int, std::string, std::string)':
guided_tour.h:17:25: error: expected '{' at end of input
guided_tour.cpp: At global scope:
guided_tour.cpp:5:19: error: expected ')' before 'ID'

Any insight here would be much appreciated!

Your code is completely wrong in almost every respect.

#define char incomingByte; //Defines incomingByte 

That line means that the compiler will substitute incomingByte; whenever it sees char.

#define char sendBack = K;

Now it will substitute sendBack = K; when it sees char.

#define char ?;

Now it will substitute ?; when it sees char.

#define pollTime;

I don’t know what you are thinking here. If you are trying to declare a variable you have to give a type, like this:

int pollTime;

bool running = true;

void setup() {
Serial.begin(9600); //Set data rate.
}
void loop() {

Those lines are OK.

for(Serial.available() > 0;)  { //Gets you the number of bytes that are available to be read from the serial port.

You don’t want the semicolon there. A for loop is not written like that. You possibly mean while, ie.

while(Serial.available() > 0) 

pollTime = delayMicroseconds(200); // Sets a poll time of 200 microseconds.

That is doing nothing of the sort. It is delaying 200 µs, it isn’t setting anything.

incomingByte  = Serial.read();

That line is OK, assuming you declared incomingByte like this, and not the way you did:

char incomingByte; 

if(incomingByte = ?) {

That needs to be in single quotes, as you are comparing a character. Also you compare with == not = ie.

if(incomingByte == '?') {

Serial.print(sendBack);

It looks from your earlier code you mean:

Serial.print('K');

  }
 }
}  

These lines look OK.

I suggest you read a beginners page about C programming. This is just pure guesswork what you are doing here. For one thing, read up on how #define works. Here is one page: https://www.techonthenet.com/c_language/constants/create_define.php. And another: http://www.cprogramming.com/reference/preprocessor/define.html

A common problem, and one that can cause a new programmer to pull their hair out.

However, it’s a problem that always has a simple solution, and with
the right tricks it’s also easy to find where the problem lies.

Let’s take the following little code snippet, which throws up this exact error:

byte i = 0;

void doSomething() {
  digitalWrite(3, LOW);
}

void doSomethingElse() {
  digitalWrite(13, HIGH);
}

void setup() {
  // put your setup code here, to run once:
  pinMode(13, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  if (i == 1) {
    doSomething();
  i++;
}

At first glance that all looks perfectly good. But you compile, and you get:

/home/matt/Arduino/ErrorTest/ErrorTest.ino: In function 'void loop()':
ErrorTest:21: error: expected '}' at end of input
 }
 ^
exit status 1
expected '}' at end of input

Line 21, of course, is the last line of the file. And the error is
pretty explicit — it expects a } at the end of the file. However, there
is plainly one there already. So what is it on about?

Simply put, there aren’t enough } to balance out the number of { in the file. For every { there must
be a } to go with it. On this little file it’s easy to just go through
and count them all. Add one for a { and subtract one for a }. If the
answer is not 0 then there’s something wrong. But it can take careful
looking to see where the missing one should be, and even I have spent
hours going cross-eyed trying to find the location in a big project.

There is one little trick, though, that can help you: Auto Format.
The Auto Format facility in both the Arduino IDE and UECIDE (and many
other IDEs as well) will sort out your indenting for you according to
the presence of (amongst other things) { and }.  If the brackets don’t
match up the formatting would end up wrong.

So let’s pass this little program through the auto formatting and see what happens:

byte i = 0;

void doSomething() {
  digitalWrite(3, LOW);
}

void doSomethingElse() {
  digitalWrite(13, HIGH);
}

void setup() {
  // put your setup code here, to run once:
  pinMode(13, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  if (i == 1) {
    doSomething();
    i++;
  }

As you can see the loop() function’s indenting has changed. And if
your eyes are sharp enough you’ll already see what was wrong. The «if»,
which had an opening bracket, didn’t have a closing one. The «i++» was
supposed to be outside the «if» (as can be seen by the original
indenting), but actually it wasn’t, and the end of the function was
really the end of the «if», leaving the function unfinished.

So fixing it is now really easy. By auto formatting we can see where the imbalance occurs, and fix it:

void loop() {
  // put your main code here, to run repeatedly:
  if (i == 1) {
    doSomething();
  }
  i++;
}

And now it compiles. But of course that little snippet doesn’t actually do anything useful…

The expected declaration or statement at end of input error always affects programs and documents when developers forget to include a symbol at the end of the function. Henceforth, professional programmers refer to it as a syntax error because it messes up the expected declaration, launching the error.

Therefore, our experts wrote this profound guide featuring many examples that recreate the error expected in your system and teach the finest solutions. In addition, you will understand more about this annoying mistake when you finish reading all chapters in this in-depth guide, so let us begin the journey.

Your system causes an expected statement or declaration at the end of an input when your document or code needs to have correct symbols at the end of the function. Consequently, the program can’t render the processes correctly, halting your project and file.

In addition, although it is rare for professional developers to experience this bug, it can affect any script because mistakes occur when writing long codes. But the good part is that many users believe debugging this syntax error is easy because including a symbol such as a bracket or a comma is not time-consuming.

However, finding the possible culprit is more challenging than fixing the syntax because your code can have several incorrectly written commands without apparent indicators. Henceforth, our experts recommend scanning the code and fixing the obvious mistakes, although this does not guarantee the solution.

As a result, this guide includes several incorrect examples that reproduce the mistake, helping readers comprehend the possible reasons. In addition, we will use the same model to provide the debugging principles, although the syntax is not very different. However, our experts confirmed an exact mistake when misplacing some commands from the primary function, such as the return and null values. So, let us recreate this annoying mistake that blocks your system.

– Writing an Incorrectly Indented Code

This error’s first cause has several commands that need more adequate closing brackets. For example, developers must close the primary and secondary orders to clarify the purpose and the code line where the function ends. Unfortunately, writing an incorrectly indented code is messy, and programmers need help locating the mistake quickly, as you will soon learn. This might severely affect your project and system.

The following example includes an incorrect code:

As you can tell, although the elements, tags, and values in this example are correct, the document does not have adequate closing brackets. In addition, the current and new commands include dependencies, which is critical when writing complex documents and applications. Unfortunately, the mistake can affect other scripts and syntaxes due to the exact reason. You can learn more about the last invalid script in the following chapter before we teach the most sophisticated debugging methods.

– Facing Issues Locating the Brackets

Although the mistake is obvious and developers can fix it quickly, several scripts include values that appear full-proof, yet the system launches the error. Henceforth, our experts will show you an example of a complex code with a single code line and function that does not have a closing bracket. We will not tell you the process that lacks the closing symbol so you can attempt to pinpoint it. In addition, this example includes correct indentation and values.

Please read the following example that has a single incorrect command:

This example confirms that a single command can ruin the entire document. Therefore, developers and programmers must react quickly and implement the debugging principles in this guide. We suggest reading the following chapter because it teaches the most optimal solutions for this mistake.

Debugging the Expected Declaration or Statement: Repeat These Steps

You can debug the expected declaration by writing the functions with proper opening and closing brackets. In technical langue, you have to use a single bracket while introducing the struct node and single dependency in your code in order to fix it.



However, the examples in the previous sections confirmed that locating the functions is only sometimes straightforward. Still, programmers must scan the entire syntax to pinpoint the syntax error, no matter how time-consuming this is. Henceforth, we will show you a short code snippet that launches the mistake before fixing the values.

The following example introduces a simple command:

Although everything looks perfect to less experienced developers, the system launches an invalid message, confirming the lack of fair brackets. So, programmers will likely experience the following message:

This invalid snippet helps users understand the exact location and implement their solution.

So, we suggest repeating the following code to debug your script and remove the error:

The last symbol closes the primary function, helping your computer understand the purpose. Consequently, any subsequent operations must follow the same syntax. However, this guide includes another practical solution that debugs your document.

– Initializing the Valid Commands

This section fixes the incorrect code from the second chapter with more complex properties. Therefore, we will take a short code snippet to analyze the inconsistencies.

This snippet is an infinite loop, which is incorrect:

However, developers must wait to modify the k value before the primary call.

So, we must introduce a struct node and a single dependency with a single bracket, as shown below:

The void and the = symbol are assignments that test the code’s equality. To top it all off, this example does not have correct closing brackets.

Instead, your code should look like this:

Moreover, our experts suggest initializing the valid commands to clarify any imperfections further. So, this example confirms nothing should stop you from fixing this mistake on your computer.

Conclusion

Your computer launches an expected statement or declaration at the end of an input when your document or code needs to have correct symbols at the end of the function. In addition, this comprehensive guide explained and exemplified the following critical points:

• Any commands and tasks that lack good opening and closing brackets will launch this annoying mistake
• Indenting your code is vital when locating the error because it looks organized
• Finding the mistake is sometimes time-consuming but is worth it because you will enable all processes
• The mistake will not disappear unless developers write closing brackets for all leading and secondary commands
• The invalid message sometimes includes indicators for the error

Facing this error is not rare at all and even seasoned developers are prone to it. So, there’s no need to overwhelm yourself because if you follow this guide step-by-step you will be able to overcome this challenge quite efficiently.