CHAPTER-1

INTRODUCTION

This note introduces some simple C++ concepts and outlines a subset of C++ that

is easier to learn and use than the full language. Although we originally wrote this

note for explaining the C++ used in the Nachos project, I believe it is useful to

anyone learning C++. I assume that you are already somewhat familiar with C

concepts like procedures, for loops, and pointers; these are pretty easy to pick up

from reading Kernighan and Ritchie's ``The C Programming Language.''

I should admit up front that I am quite opinionated about C++, if that isn't obvious

already. I know several C++ purists (an oxymoron perhaps?) who violently

disagree with some of the prescriptions contained here; most of the objections are

of the form, ``How could you have possibly left out feature X?'' However, I've

found from teaching C++ to nearly 1000 undergrads over the past several years

that the subset of C++ described here is pretty easy to learn, taking only a day or so

for most students to get started.

The basic premise of this note is that while object-oriented programming is a

useful way to simplify programs, C++ is a wildly over-complicated language, with

a host of features that only very, very rarely find a legitimate use. It's not too far

off the mark to say that C++ includes every programming language feature ever

imagined, and more. The natural tendency when faced with a new language feature

is to try to use it, but in C++ this approach leads to disaster.

Thus, we need to carefully distinguish between (i) those concepts that are

fundamental (e.g., classes, member functions, constructors) -- ones that everyone

should know and use, (ii) those that are sometimes but rarely useful (e.g., single

inheritance, templates) -- ones that beginner programmers should be able to

recognize (in case they run across them) but avoid using in their own programs, at

least for a while, and (iii) those that are just a bad idea and should be avoided like

the plague (e.g., multiple inheritance, exceptions, overloading, references, etc).

5510252 1

Of course, all the items in this last category have their proponents, and I will admit

that, like the hated goto, it is possible to construct cases when the program would

be simpler using a goto or multiple inheritance. However, it is my belief that most

programmers will never encounter such cases, and even if you do, you will be

much more likely to misuse the feature than properly apply it. For example, I

seriously doubt an undergraduate would need any of the features listed under (iii)

for any course project (at least at Berkeley this is true). And if you find yourself

wanting to use a feature like multiple inheritance, then, my advice is to fully

implement your program both with and without the feature, and choose whichever

is simpler. Sure, this takes more effort, but pretty soon you'll know from

experience when a feature is useful and when it isn't, and you'll be able to skip the

dual implementation.

1.1 Importance:

Nowadays, technologies have advanced to a large degree. Now each day, the result

of technology could be felt everywhere. Several work processes which formerly

required a lengthy period of time now takes lesser time by automated software.

Within the domain names of billing invoicing software may come to great help.

Billing software has all of the accounting concepts integrated within it and

therefore the job of accounting is made easier. Billing software programs and

companies are offered online.

Billing systems integrated in these software would also help to create fast print

outs of bills. Billing systems can compute complex bills within a few minutes and

therefore the job associated with a store keeper and accountant is created is a lot

easier. First and foremost Billing systems in this software are simple to understand

and also to execute or you can outsource all of your billing services.

If one should download any billing software that will compute the entire values of

invoice or would generate invoice in a few minutes then you can get such billing

invoice software from the internet. You can get billing software in from many

reputable sites which permit download of the latest software. Anyone with the

smallest idea of using computer and accounting using computer can really take full

advantage of such out of the box programs. Any Software for billing ought to be

handled with utmost care because they’re automated software and therefore a small

mistake can set a series of mistakes within the Billing systems from the Software

5510252 2

for billing. For this reason and if your billing processes are more sophisticated, you

may need a customized solution which there are companies out there that can help

you achieve. Billing and Accounting Software allows you to definitely maintain

multiple company records, customer-vendor records; tax related and inventory

management information, earnings and expenses particulars of the organization

with the aid of advanced barcode technology. Selecting the best billing software or

service company for the office is important to developing profitability and

efficiency. Billing software or service companies might help simplify useless

office tasks and again place the focus back on reaching your practice goals

1.2 Objective

The following objectives have been set:

Add and maintain records of available products.

Add and maintain description of new products.

Add and maintain new entered category of products.

Provide economic /financial reports to owner monthly or weekly and

yearly.

Provide a convenient solution of billing pattern.

Make an easy to use environment for users and customers.

Accuracy, timeliness and comprehensiveness of the system output.

Enhancement in the completion of work within the constraints of time

5510252 3

CHAPTER-2

SYSTEM ANALYSIS

2.1 FEASIBILITY STUDY

2.1.1 Economic feasibility

Economic analysis is the most frequently used method for evaluating the

effectiveness of a new system. More commonly known as cost/benefit analysis,

the procedure is to determine the benefits and savings that are expected from a

candidate system and compare them with costs. If benefits outweigh costs, then the

decision is made to design and implement the system. An entrepreneur must

accurately weigh the cost versus benefits before taking an action

Cost Based: No special investment is needed to manage the tool. No specific

training is required for employees to use the tool. Investment requires only once at

the time of installation. The software used in this project is freeware so the cost of

developing the tool is minimal

2.1.2 Legal feasibility

Determines whether the proposed system conflicts with legal requirements, e.g. a

Data Processing system must comply with the local Data Protection Acts.

2.1.3 Operational feasibility

Is a measure of how well a proposed system solves the problems, and takes

advantages of the opportunities identified during scope definition and how it

satisfies the requirements identified in the requirements analysis phase of system

development.

2.1.4 Schedule feasibility

A project will fail if it takes too long to be completed before it is useful. Typically

this means estimating how long the system will take to develop, and if it can be

completed in a given time period using some methods like payback period.

Schedule feasibility is a measure of how reasonable the project timetable is. Given

our technical expertise, are the project deadlines reasonable? Some projects are

initiated with specific deadlines. You need to determine whether the deadlines are

mandatory or desirable.

5510252 4

2.1.5 Market and real estate feasibility

Market Feasibility Study typically involves testing geographic locations for a real

estate development project, and usually involves parcels of real estate land.

Developers often conduct market studies to determine the best location within a

jurisdiction, and to test alternative land uses for a given parcels. Jurisdictions often

require developers to complete feasibility studies before they will approve a permit

application for retail, commercial, industrial, manufacturing, housing, office or

mixed-use project. Market Feasibility takes into account the importance of the

business in the selected area.

2.1.6 Resource feasibility

This involves questions such as how much time is available to build the new

system, when it can be built, whether it interferes with normal business operations,

type and amount of resources required, dependencies, etc. Contingency and

mitigation plans should also be stated here.

2.1.7 Cultural feasibility

In this stage, the project's alternatives are evaluated for their impact on the local

and general culture. For example, environmental factors need to be considered and

these factors are to be well known. Further an enterprise's own culture can clash

with the results of the project

5510252 5

CHAPTER-3

SYSTEM DESIGN

Describes desired features and operations in detail, including screen layouts,

business rules, process diagrams, pseudocode and other documentation.

unctions and Parameters

3.1 Introduction

Functions are used to break a programming problem up into reasonable chunks. A

function should be cohesive, which means that it should have one overall task. Do

not have a function carry out several unrelated actions. When a function is called,

the code for the function is executed. When the function code has been executed,

program execution continues at the point right after the function call.

Parameters are used to send data into a function. Ordinary parameters use call-by-

copy. This means that each formal parameter (parameter name used inside the

function code) gets a copy of the value of the corresponding actual parameter (the

variable or value that is used in the function call). Of course, the first actual

parameter gets matched with the first formal parameter, the second actual

parameter with the second formal parameter, etc.

Reference parameters are used to send data back out of a function. A reference

parameter is normally indicated by an & between the type name and the formal

parameter name. Values can also be sent into the function via a reference

parameter. The key idea is that any change made by the function to such a

parameter is sent back out of the function. A reference parameter is said to use

call-by-reference.

Data can also be send back out of a function in the function name itself. This is

accomplished by using a return statement inside the code for the function. For

example, return x; would send the value of x back in the function name.

A First Example

Let's look at an example program, fn.cpp, that illustrates many of these features.

Read through the code and try to identify the ways that data is sent into and back

out of the functions. (If you wish, save a copy of the code, compile it, and run it to

see more exactly what it does.) Then read the following description to see if you

got it right!

5510252 6

The Run-Time Stack

Program execution begins at the start of the main function, of course. The main

function in this program has variables Length, Width, Area, and Perim. Space is

saved for these variables in an area of main memory called the run-time stack. The

section of the run-time stack for the main function is shown below. Note that there

is more room available at the top end of this stack should we need it. Since the

main function begins by assigning values to variables Length and Width, these

values are shown in the drawing of the run-time stack.

Fig. 3.1 Run-Time Stack

Next, the main function calls the FindArea function as follows:

FindArea(Length, Width, Area);

The variables Length, Width, and Area inside these parentheses are the actual

parameters. They correspond in order from left to right to the three formal

parameters found in the code for the function, shown below.

void FindArea(float Length, float Width, float & Area)

{

Area = Length * Width;

}

When a function call is reached, a stack frame (sometimes called an activation

record) is placed on the run-time stack. We will use a simplified picture of a stack

frame that ignores some of the technical details (such as the local base or base

pointer) and does not look at differences that exist between various platforms (such

as Windows versus Linux).

5510252 7

In our picture, the first items in the stack frame are the parameters. Then comes

the so-called return address, while the last items would be local variables (but our

example has no local variables). The first two formal parameters are non-reference

(call-by-copy) parameters. Thus, in the picture of the run-time stack below, you see

that the 3.4 and 1.2 have been copied into these formal parameters. The third

formal parameter, Area, is a reference parameter. No value is stored in a reference

parameter. Rather, it contains a pointer to the corresponding actual parameter. In

our example the formal parameter Area contains a pointer to the variable also

called Area in the main function section of the stack. The pointer is essentially the

main memory address of the item pointed to, but is more conveniently drawn as an

arrow instead of a number.

The return address is the location in the compiled, executable code to return to

when the called function has completed. In our example, program execution should

continue on the line following the function call. Since this return address is a

number indicating a location in the compiled machine code, no attempt is made to

show the number itself, as it will vary from computer to computer and may even

vary from one run to another on the same computer.

Fig 3.2 Return address

Note that the stack grows from high addresses to low addresses in memory, at least

on most computers. This is backwards of what you might expect, but works fine as

long as you don't run out of free memory by running up against something else at

5510252 8

the low end of memory. However, even on a computer whose stack grows from

low to high memory addresses, it is possible to run up against something else on

the high end.

When the function multiplies the length and width to get the area, this value, 4.08,

is stored by following the pointer for the Area reference parameter. Thus the

answer gets stored in the Area variable for function main. This is the mechanism

that a reference parameter uses in order to send an answer back to whatever

function called this function.

When the end of the function FindArea is reached, the return address is used to tell

where to continue with the execution of the program. The stack frame for FindArea

is also removed from the stack. (Actually, it is not really erased. Rather, some

indicator of where the top item is on the stack is just moved. This indicator is

typically called the stack pointer.) Note that the parameters Length, Width, and

Area are now gone. They have a short lifetime! Their lifetime begins when the

function is called and is over when the function is finished.

One can also talk about the scope of a variable, parameter, or other identifier. The

scope is that section of code where it is legal to use that identifier. In our example

program, parameters Length, Width, and Area have as scope the section of code

comprising function FindArea. Those parameters don't exist outside of this

function.

In any case, once function FindArea ends and its stack frame is removed, the run-

time stack looks like this:

Fig. 3.3 Function Find Ares

5510252 9

Next, as program execution continues in the main function, we see that main calls

function FindPerim as follows:

Perim = FindPerimeter(Length, Width);

Since this function is returning a value in its function name, this may well be

handled by using a mechanism similar to a reference parameter. We will assume

that the compiler will set things up so that a temporary variable is put on the stack

for the main function before putting on the stack frame for function FindPerimeter.

The stack frame for FindPerimeter will start with the parameters (both value or

non-reference parameters) Length and Width, each containing a copy of the

corresponding actual parameter. Next, in order to return a value via the function

name, the stack frame has a location (labelled Temp in the drawing below) that

acts like a reference parameter in that it contains a pointer to the Temp variable for

the main function. Finally we have the return address of where to go back to in the

main function. There are no local variables for this function, but if there were, they

would after the return address.

Fig. 3.4 Fins Parimeter

5510252 10

3.2. Layout of the proposed Network

Fig 3.2.1 Data Flow Diagram

5510252 11

Fig 3.2.2 Data Flow Diagram

5510252 12

CHAPTER-4

SYSTEM IMPLEMENTATION

Requirement specification

4.1 Software

The software required for the project are as under……

1. A full functional window like Xp/Xp7.

2. Installed the full setup of C++.

3. Installed the full setup of Ms Office including Ms Word, Ms PowerPoint

etc.

4. Software of printer which is connected.

HARDWARE:- The hardware required for the project are as under……

1. A Pentium 4 or higher processor/CPU.

2. 512 or higher RAM.

3. Approximate 2GB or more hard disk space.

4. A CD/DVD read/writer.

5. 15inches or high resolution monitor/LCD.

6. A keyboard.

7. A mouse.

8. A UPS of better backup.

9. An inkjet or laser printer.

5510252 13

4.2 Project Configuration

Fig 4.2.1

5510252 14

Fig 4.2.2

Enter the record:

Fig 4.2.3

5510252 15

Fig 4.2.4

Fig 4.2.5

5510252 16

Fig 4.2.6

Fig 4.2.7

Enter the choice if you want to enter more data:

5510252 17

Fig 4.2.8

Fig 4.2.9

Enter “d”to display record:

5510252 18

Fig 4.2.10

Display record:

Fig 4.2.11

Searching record:

5510252 19

Fig 4.2.12

Fig 4.2.13

enter choice to search the record:

5510252 20

Fig 4.2.14

Fig 4.2.15

Enter choice for deleting the record:

5510252 21

Fig 4.2.16

Fig 4.2.17

5510252 22

Fig 4.2.18

Fig 4.2.20

5510252 23

Fig 4.2.21

CHAPTER-5

SYSTEM TESTING AND TROUBLESHOOTING

System testing of software or hardware is testing conducted on a complete,

integrated system to evaluate the system's compliance with its specified

requirements. System testing falls within the scope of black box testing, and as

such, should require no knowledge of the inner design of the code or logic.

As a rule, system testing takes, as its input, all of the "integrated" software

components that have passed integration testing and also the software system itself

integrated with any applicable hardware system(s). The purpose of integration

testing is to detect any inconsistencies between the software units that are

integrated together (called assemblages) or between any of the assemblages and the

hardware. System testing is a more limited type of testing; it seeks to detect defects

both within the "inter-assemblages" and also within the system as a whole.

System testing is performed on the entire system in the context of a Functional

Requirement Specification(s) (FRS) and/or a System Requirement Specification

5510252 24

(SRS). System testing tests not only the design, but also the behaviour and even the

believed expectations of the customer. It is also intended to test up to and beyond

the bounds defined in the software/hardware requirements specification

5.1 Types of tests to include in system testing

The following examples are different types of testing that should be considered

during System testing:

5.2 Graphical user interface testing

In software engineering, graphical user interface testing is the process of testing a

product's graphical user interface to ensure it meets its written specifications. This

is normally done through the use of a variety of test cases.

5.3 Usability testing

Usability testing is a technique used in user-centered interaction design to evaluate

a product by testing it on users. This can be seen as an irreplaceable usability

practice, since it gives direct input on how real users use the system.[1] This is in

contrast with usability inspection methods where experts use different methods to

evaluate a user interface without involving users.

Usability testing focuses on measuring a human-made product's capacity to meet

its intended purpose. Examples of products that commonly benefit from usability

testing are foods, consumer products, web sites or web applications, computer

interfaces, documents, and devices. Usability testing measures the usability, or

ease of use, of a specific object or set of objects, whereas general human-computer

interaction studies attempt to formulate universal principles.

5.4 Software performance testing

5510252 25

n software engineering, performance testing is in general testing performed to

determine how a system performs in terms of responsiveness and stability under a

particular workload. It can also serve to investigate, measure, validate or verify

other quality attributes of the system, such as scalability, reliability and resource

usage.

Performance testing is a subset of performance engineering, an emerging computer

science practice which strives to build performance into the implementation,

design and architecture of a system.

5.5 Compatibility testing

Compatibility testing, part of software non-functional tests, is testing conducted on

the application to evaluate the application's compatibility with the computing

environment. Computing environment may contain some or all of the below

mentioned elements:

5.6 Exception handling

Exception handling is the process of responding to the occurrence, during

computation, of exceptions – anomalous or exceptional events requiring special

processing – often changing the normal flow of program execution. It is provided

by specialized programming language constructs or computer hardware

mechanisms.

In general, an exception is handled (resolved) by saving the current state of

execution in a predefined place and switching the execution to a specific

subroutine known as an exception handler. If exceptions are continuable, the

handler may later resume the execution at the original location using the saved

information. For example, a floating point divide by zero exception will typically,

by default, allow the program to be resumed, while an out of memory condition

might not be resolvable transparently.

5.7 Load testing

5510252 26

Load testing is the process of putting demand on a system or device and measuring

its response. Load testing is performed to determine a system’s behavior under

both normal and anticipated peak load conditions. It helps to identify the maximum

operating capacity of an application as well as any bottlenecks and determine

which element is causing degradation. When the load placed on the system is

raised beyond normal usage patterns, in order to test the system's response at

unusually high or peak loads, it is known as stress testing. The load is usually so

great that error conditions are the expected result, although no clear boundary

exists when an activity ceases to be a load test and becomes a stress test.

There is little agreement on what the specific goals of load testing are.[citation

needed] The term is often used synonymously with concurrency testing, software

performanc

CHAPTER-6

CONCLUSION AND FUTURE SCOPE

CONCLUSION

At the end of the project we find that the “BILLING” play an important role in the

shops, malls etc. We can save many records in a single file. So that we can save the

wastage of papers. With the help of this project we can easily & quickly see the

record of any product of computer which we want only just pressing a key of that

record. With the help of this type of projects the office’s works are going very fast

without wasting time. And only a single person/employee can handle this project.

So that this project helps to save time & money.

So these projects can helps us in the future to give a fast/quick response in

searching process. And this project also helps us to save money & time. These

projects would be helpful for the new employee.

In simple words this project is need of the future.

5510252 27

FUTURE SCOPE

This project will help the store keeper in fast billing.

This project enable store keeper to maintain a great database of all

customer visited and purchase product from store.

Project will enable to see report regarding product and category.

Easy to maintain in future prospect.

REFERENCES

http://www.wikipedia.org http://www.cplusplusonline.org http://www.ncseonline.org

5510252 28