Operators play an important part in every programming language as they set the groundwork for the programming. Users can utilize operators to perform various operations on operands. Solidity provides the following categories of operators depending on their functionality.  

• Operators in Arithmetic  
• Relative Operators
• Logical Operators
• Assignment operators
• Bitwise Operators

‍

Enum
‍Enums are user-defined data types typically used to give names for integral constants, making the contract easier to maintain and comprehend. With Enums, you can only assign one of a small set of predetermined values to a variable. A default value for the Enum can be specified, and integers starting at zero represent the available options. Bugs in the code can be minimized by switching to Enums.
enum <enumerator_name> {element 1, element 2,....,element n}

‍Struct
‍Structs in Solidity enable the creation of more complex data types with multiple features. You can create your type by constructing a struct.
They are handy for grouping pertinent data.
Declaring structs outside of one contract and importing them into another is possible. In general, it is used to represent a record. The struct keyword is used to construct a structure, which produces a new data type.
Syntax
struct <structure_name> {  
<data type> variable_1;  
<data type> variable_2;  
}

Smart contracts are high-level program codes compiled into EVM byte code before being published to the Ethereum network. It enables us to conduct trustworthy transactions without the need for a trusted third party, and these deals are both auditable and final. Solidity, a language library akin to JavaScript and C, Serpent, a low-level Lisp-like language called LLL, and Mutan, a Go-based language, are the languages used to create smart contracts. ''Serpent'' is similar to Python but is no longer supported.

A variable is a placeholder for data that can be changed at runtime. Users can access and modify the data at any time by using variables.
‍Variable Naming Guidelines
1. Variable names should not contain reserved keywords.
2. Variable names must begin with a letter or an underscore (_) and may include letters ranging from "a to z" or "A to Z," as well as figures ranging from "0 to 9" and characters.
3. The name of variables is case sensitive

Example:
1. Valid variable names: Geeks123, geeks, _123geeks
2. Invalid variable names: 123geeks, $Geeks, 12_geeks  

Declaration of Variable:
In Solidity, a variable declaration is slightly different; to define a variable, the user must first provide the data type, followed by an access modifier.  
Syntax: <type> <access modifier> <variable name>
‍Various types of variables
‍As Solidity is a statically typed language, each declared variable is guaranteed to have a default value consistent with its data type. As a result, the terms "null" and "undefined" are not applicable. In Solidity, you may use three distinct types of data:
1. State Variables: The values of these variables are permanently recorded in the contract storage. State variables should be declared outside of a function's scope whenever possible.
2. Local Variable: These variables' values remain present until the function executes and cannot be retrieved outside of that function. This variable type is typically used for storing temporary data.
3. Global Variables: Global variables are unique variables that may be utilized worldwide to provide information about transactions and blockchain characteristics.

The solidity fallback function is executed if no other parts match the function identifier or if no parameters were supplied with the function request. A contract's single, nameless process is called whenever it receives an Ether transaction without further data. The fallback function is set to payable to add Ether to the contract's total balance. The contract will throw an error if it attempts to accept Ether via standard transactions while no such function is available.  

Features of a fallback function:

• Declare fallback () without any parameters.  
• If it is not designated payable, the contract will throw an exception if it gets raw Ether without data.  
• I am unable to accept returns.  
• It is specified just once per contract.  
• It is also run if the caller intended to call a method that is unavailable if receive () does not exist or if msg. Data is not empty.
• It must be marked as external.
• When invoked by another function using the transfer () or send () methods, it is restricted to 2300 gas. It goes so far as to make this function call as inexpensive as feasible.

Inheritance is one of the most essential components of the object-oriented programming language. It is a method of extending the functionality of a program that is used to segregate the code, decrease dependence, and enhance the re-usability of existing code.
Solidity allows smart contracts to inherit from one another, allowing numerous contracts to be inherited into a single contract. A derived contract is one that inherits features from a base contract, which is the contract from which additional contracts derive their features. They are commonly referred to as parent-child contracts. Solidity only allows inheritance between classes with public and internal modifiers.
Types of Inheritances Possible in Solidity

• Single Inheritance - In single or single-level inheritance, just one derived contract inherits the functions and variables of one base contract.  
• Multi-level Inheritance - It is identical to single inheritance but includes additional layers of the parent-child relationship. When one contract is derived from another, the derived contract also takes on the role of parent to the original contract.
• ‍Hierarchical Inheritance - A parent contract has more than one child contract under hierarchical inheritance. Its primary use is the deployment of a shared capability in numerous settings.
• ‍Multiple Inheritance - A single contract can be inherited from numerous contracts under Multiple Inheritance. A parent contract can include more than one child, but a child contract can have more than one parent.