- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# Program to construct DFA for Regular Expression C( A + B)+

In this article, we will be discussing how to construct a Deterministic Finite Automaton (DFA) for the Regular Expression C(A + B)+ using C++. We'll start by understanding the problem and the theory behind it, then we'll dive into the implementation and conclude with a relevant example to demonstrate its use.

## Understanding the Problem Statement

A Deterministic Finite Automaton (DFA) is a theoretical model of computation used in automata theory, a branch of theoretical computer science. It's one of the simplest types of automata and an essential concept in the study of compilers and parsers.

The task here is to program a DFA for the Regular Expression C(A + B)+. This expression can be interpreted as 'C' followed by one or more occurrences of either 'A' or 'B'. Our goal is to create a C++ program that will check if a given input string matches this Regular Expression.

## Theoretical Background

A DFA consists of a set of states and transitions between those states on input symbols. It starts from an initial state and reads the input symbols. For each input symbol, it transitions to a new state until all input symbols have been read. The DFA accepts the input if and only if it ends in a final (or accepting) state.

In this case, the DFA for the Regular Expression C(A + B)+ can be visualized as follows −

Start state: q0

Accepting state: q2

Transitions −

q0 on input 'C' goes to q1

q1 on input 'A' or 'B' goes to q2

q2 on input 'A' or 'B' stays at q2

### Example

Now let's implement this DFA in C++. Note that this program will only work with uppercase 'A', 'B', and 'C'.

#include <iostream> #include <string> using namespace std; enum State { q0, q1, q2, q3 }; State getNextState(State currentState, char input) { switch (currentState) { case q0: return (input == 'C') ? q1 : q3; case q1: return (input == 'A' || input == 'B') ? q2 : q3; case q2: return (input == 'A' || input == 'B') ? q2 : q3; default: return q3; } } bool matchesRE(string s) { State currentState = q0; for (char c : s) { currentState = getNextState(currentState, c); } return currentState == q2; } int main() { string test = "CABAB"; cout << (matchesRE(test) ? "Matches Regular Expression" : "Does not match Regular Expression") << endl; return 0; }

### Output

Matches Regular Expression

## Test Case

Let's use the string "CABAB" as an example. This string starts with 'C' and is followed by a sequence of 'A's and 'B's. Therefore, it matches the Regular Expression C(A + B)+, and the output of the program will be: "Matches Regular Expression".

## Conclusion

In this article, we have taken a closer look at the theoretical model of computation, DFA, and its application in validating Regular Expressions. We have focused on the Regular Expression C(A + B)+ and created a C++ program to check if an input string matches this Regular Expression. We hope this discussion has been informative and has helped you understand DFAs and their implementation in C++ better.