Scope resolution in Compiler Design - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to access the global variable inside the function.

Compiler Design

int x = 10;
void func() {
    int x = 5;
    printf("%d", [1]);
}

Drag options to blanks, or click blank then click option'

A::x

Bx

Cthis->x

Dglobal::x

Attempts:

3 left

💡 Hint

Common Mistakes

Using just the variable name accesses the local variable.

Using 'this->x' is for class members, not global variables.

The scope resolution operator :: accesses the global variable x inside the function.

2fill in blank

medium

Complete the code to access the class static member variable using scope resolution.

Compiler Design

class MyClass {
public:
    static int count;
};

int main() {
    MyClass::[1] = 5;
    return 0;
}

Drag options to blanks, or click blank then click option'

Athis->count

Bcount

Ccount()

Dstatic count

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this->count' causes an error because static members are not tied to instances.

Trying to call 'count()' as a function is incorrect.

The static member variable is accessed using the class name and scope resolution operator followed by the variable name.

3fill in blank

hard

Fix the error in accessing the nested namespace variable using scope resolution.

Compiler Design

namespace Outer {
    namespace Inner {
        int value = 42;
    }
}

int main() {
    int x = [1];
    return 0;
}

Drag options to blanks, or click blank then click option'

AOuter.Inner::value

BOuter->Inner->value

COuter.Inner.value

DOuter::Inner::value

Attempts:

3 left

💡 Hint

Common Mistakes

Using dots '.' instead of '::' causes syntax errors.

Using arrows '->' is invalid for namespaces.

Namespaces are accessed using the scope resolution operator :: between each namespace and variable.

4fill in blank

hard

Fill both blanks to correctly define and access a static member function using scope resolution.

Compiler Design

class Calculator {
public:
    static int [1]() {
        return 100;
    }
};

int main() {
    int result = Calculator::[2]();
    return 0;
}

Drag options to blanks, or click blank then click option'

AgetValue

BgetValue()

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Including parentheses in the function declaration name causes syntax errors.

Omitting parentheses when calling the function causes errors.

The static member function is declared as getValue without parentheses in the definition and accessed with parentheses when called.

5fill in blank

hard

Fill all three blanks to correctly define and access a variable inside nested classes using scope resolution.

Compiler Design

class Outer {
public:
    class Inner {
    public:
        static int [1];
    };
};

int Outer::Inner::[2] = 50;

int main() {
    int val = Outer::Inner::[3];
    return 0;
}

Drag options to blanks, or click blank then click option'

Adata

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names in declaration and definition causes errors.

Omitting scope resolution in definition or access causes errors.

The static variable data is declared inside the nested class, defined outside with full scope, and accessed using scope resolution.

Practice

1. What is the main purpose of the :: operator in scope resolution?

easy

A. To specify which scope a variable or function belongs to

B. To declare a new variable

C. To perform arithmetic operations

D. To create a loop

Solution

1. Step 1: Understand the role of scope resolution

   The :: operator is used to access variables or functions that belong to a specific scope, especially when multiple scopes have the same name.

2. Step 2: Identify the correct use of ::

   It helps avoid confusion by explicitly stating which scope to use, such as a global variable or a class member.

3. Final Answer:

   To specify which scope a variable or function belongs to -> Option A

4. Quick Check:

   Scope resolution operator = specify scope [OK]

Hint: Remember :: means 'from this scope' [OK]

Common Mistakes:

• Confusing :: with assignment operator
• Thinking it declares variables
• Using it for arithmetic

2. Which of the following is the correct syntax to access a global variable named x inside a function when a local variable with the same name exists?

easy

A. global x

B. ::x

C. global::x

D. ::x

Solution

1. Step 1: Identify the correct scope resolution syntax

   In many languages like C++, the global scope resolution operator is :: placed before the variable name to access the global variable.

2. Step 2: Choose the syntax that correctly uses the operator

   The correct syntax is ::x to access the global variable x inside a function where a local x exists.

3. Final Answer:

   ::x -> Option B

4. Quick Check:

   Global variable access = ::x [OK]

Hint: Use :: before variable for global access [OK]

Common Mistakes:

• Using 'global x' which is not scope resolution
• Writing 'global::x' which is invalid syntax
• Omitting the operator

3. Consider the following code snippet:

int x = 10;
void func() {
  int x = 20;
  print(::x);
}

What will be printed when func() is called?

medium

A. 20

B. 0

C. 10

D. Error

Solution

1. Step 1: Identify the scopes of variable x

   There is a global x with value 10 and a local x inside func() with value 20.

2. Step 2: Understand ::x usage in print(::x)

   The ::x accesses the global x, ignoring the local one.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Scope resolution prints global x = 10 [OK]

Hint: <::x> always means global variable [OK]

Common Mistakes:

• Printing local x instead of global
• Confusing syntax causing error
• Assuming default prints local variable

4. Identify the error in the following code snippet:

int x = 5;
void func() {
  int x = 10;
  print(x::);
}

medium

A. Incorrect use of scope resolution operator

B. Variable redeclaration error

C. Missing semicolon

D. No error

Solution

1. Step 1: Analyze the syntax of scope resolution operator

   The scope resolution operator :: must precede the variable or function name, not follow it.

2. Step 2: Identify the incorrect usage in print(x::);

   Here, x:: is invalid syntax; it should be ::x to access global scope or just x for local.

3. Final Answer:

   Incorrect use of scope resolution operator -> Option A

4. Quick Check:

   Operator must be before variable [OK]

Hint: Scope operator goes before name, not after [OK]

Common Mistakes:

• Placing :: after variable name
• Confusing with member access operator
• Ignoring syntax rules

5. Given two nested namespaces:

namespace Outer {
  int value = 100;
  namespace Inner {
    int value = 200;
    int getValue() {
      return Outer::value + value;
    }
  }
}

What will Outer::Inner::getValue() return?

hard

A. Compilation error

B. 200

C. 100

D. 300

Solution

1. Step 1: Identify values in each namespace

   Outer::value is 100, and Inner::value is 200.

2. Step 2: Calculate the return value of getValue()

   The function returns Outer::value + value, where value refers to Inner::value. So, 100 + 200 = 300.

3. Final Answer:

   300 -> Option D

4. Quick Check:

   Outer + Inner values = 300 [OK]

Hint: Add outer and inner values using scope operator [OK]

Common Mistakes:

• Assuming only inner value is returned
• Confusing namespaces and scopes
• Expecting compilation error due to nested namespaces