Here is a concise way to model basic bank account operations in Python using classes:

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
        
    def deposit(self, amount):
        self.balance += amount
        
    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
        else:
            print("Insufficient funds")
            
    def get_balance(self):
        return self.balance

To use it:

my_account = BankAccount(100)
my_account.deposit(50)
print(my_account.get_balance()) # Prints 150
my_account.withdraw(75) 
print(my_account.get_balance()) # Prints 75

This models key bank account functions like initial balance, depositing funds, withdrawing funds (with overdraft protection), and checking the current. The class encapsulates the account data and operations together for easy reuse.

Sure, I'll provide a simple illustrative example using Python:

class BankAccount:
    def __init__(self, account_name, balance=0):
        self.account_name = account_name
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"{self.account_name}'s account credited with {amount}. New balance is {self.balance}")

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            print(f"Amount {amount} withdrawn from {self.account_name}'s account. New balance is {self.balance}")
        else:
            print('Insufficient balance for withdrawal')

    def inquire_balance(self):
        print(f"{self.account_name}'s account balance : {self.balance}")


# Creating a new bank account
a1 = BankAccount('John Doe', 2000)

# Deposit amount
a1.deposit(500)

# Withdraw amount
a1.withdraw(1000)

# Inquire Balance
a1.inquire_balance()

This simple program is designed to illustrate a basic system for bank account operations. ABankAccount class models the account, with methods for depositing (deposit), withdrawing (withdraw), inquiry (inquire_balance`). Please note, in production code, you'd probably want more robust error checking and to handle edge cases.

Alright, let's model a basic bank account system in C++.

#include<iostream>
#include<string>
using namespace std;

class BankAccount {
   private:
   string accountName;
   double balance;

   public:
   BankAccount(string name, double balance)
    : accountName(name), balance(balance) {}

    deposit(double amount) {
        balance += amount;
        cout << accountName << "'s account has been credited with " << amount <<
               ". New balance is " << balance << ".\n";
    }

    void withdraw(double amount) {
        if (balance >= amount){
            balance -= amount;
            cout << "Amount " << amount << " withdrawn from " << accountName << "'s account" <<". New balance is "
            << balance  << ".\n";
        }
        else{
            cout << "Insufficient balance for withdrawal.\n";
        }
    }
  
    void balanceInquiry() const {
        cout << accountName << "'s account balance: " << balance << ".\n";
    }
};

int main() {
    BankAccount account1("John Doe", 2000);

    account1.deposit(500);
    account1.withdraw(1000);
    account1.balanceInquiry();

    return 0;
}

In the above C++ code, we're setting up a class called BankAccount. This class maintains two private aspects : accountName and balance . The public methods are there for handling deposits(deposit), withdrawals(withdraw) and balance inquiries(balanceInquiry). In main(), we're creating an instance of BankAccount and performing various operations.

Please note that we are not doing any error checking for edge cases here. This is a simplified example meant to illustrate the concept. In real-world production code, error handling, security, and persistence would be key considerations.