Search results
Top results related to microsoft access sample inventory database example java c++
Top Answer
Answered May 16, 2010 · 4 votes
- C: device drivers and other low level things
- C++: applications where you don'twant to annoy the user by having toinstall a runtime environment
- C/C++: realtime applications; or incases where the programs runtime isextremely short (the C/C++ programterminates before the jvm startup isdone); in cases where memoryfootprint has to be small
- Java: in nearly all other cases(provided no better suited domainspecific language exists); mobileapplications; web (especially on theserver)
performance of java is IMHO no more an issue. It is at least comparable to C++, and in many cases it's even superior to that of C++ - we reimplemented a large number crunching application in java and it runs an order of magnitude faster than the old one implemented in C++. Surprising? Well, I think the main reason is better tooling support, faster turn-around cycles and less time spent for plugging existing libraries together: Using Java, we have more time to concentrate on algorithms. Plus, some things that can slow down C++ applications simply are not an issue with jave (like temporary object creation).
concerning GUI development, I think swing has come a long way and SWT is native, so here java is an option, too.
Standard C++ should be portable at the source level in theory, but in practice it's not. Not just threads, but also networking, file system access (i.e. no standard function to tell a files' size), etc.
And even incompatibility on one platform is an issue - we have std::string, but how many libraries still exist using their own string classes? If I build my GUI with one library and want to store data in a databse, I'll sure have to convert first.
Another example: If I want to use regular expressions, should I go for boost::regex or the GNU library?
1/5
Top Answer
Answered Mar 04, 2015 · 3 votes
In C++ when protected is used only a subclass can access the member (the analog to Field in Java).
Access specifiers are also for member functions / methods, not just member variables / fields.
In C++ there is also the "friend" classes that can have access to private/protected mambers of the class that giving "friendship". This is little bit analogous to "package" field modifier in Java (default field modifier), except that in C++ a friendship gives access to all private members, but in Java the access from classes in the same package is specific for a class field.
There are not only friend classes but also functions.
It's true that Java's package-private access is similar, but it's not a complete replacement. A better way to put it would be that those two features have a subset of problems they solve. There are problems that can be solved by friend but not by package-private, and vice versa.
What I couldn't understand is, assuming that I want to give access only to subclasses, this is something I can do in C++ by declaring the members protected in a class that doesn't "give" friendships.
But in Java, I don't know how can I do it,
The answer is: You cannot.
since by using "protected" field modifier - I also give access to all classes in the package.
Exactly.
The only way that I find to do it is to declare the field protected and have the class isolated in its package.
Technically, yes. But this creates other problems. Your class will no longer be able to access package-private elements of its previous package. Let's say your BaseClass used to be in com.example.one. You move it to com.example.two. Now it will no longer be able to access other package-private classes of com.example.one.
Is this indeed the leading consideration in package grouping?
Yes, Java is designed like this. You can try to fight the language rules, but that's a losing battle in any programming language.
Another thing I don't understand, In Java, assuming I have two fields in the class A: b,c. I want to give B access to b but not to c, and I want to give C access to c but not to b. and to the "World" I want b,c to be hiden. How can it be done?
It cannot be done in a clean way (by clean I mean: without any hacks that would require you to inspect the call stack at runtime and throw exceptions).
If you are concerned about this scenario because you are designing a public API, a low-tech solution which usually works perfectly is to create one or more *.internal packages and clearly document the fact that those are not supposed to be used in client code.
2/5
Top Answer
Answered Sep 11, 2009 · 3 votes
There are two big features/advantages that Java/C# have over C++:
- Built-in garbage collection/managed memory. You don't have to worry about cleaning up your objects. Garbage collection is coming/available for C++ as well, but it's considerably less convenient to use. Java/C# make it like the air you breath. It hard to understate how much this can help your productivity and how much enjoyment this can add to your coding.
- The Well-organized built-in API/library. C++ probably has a much larger library available to it, if for no other reason than it's been around much longer and you can run it on my platforms, Java and C# are set apart by the amount of time, depth, and organization that went into the library that actually ships with the language.
On the other hand, Java/C# depend on an external runtime. The lack of this dependency means that C/C++ are everywhere. You can use C++ to program for almost any random esoteric platform out there, no matter what the constraints.
3/5
Top Answer
Answered May 23, 2017 · 178 votes
Generally, C# and Java can be just as fast or faster because the JIT compiler -- a compiler that compiles your IL the first time it's executed -- can make optimizations that a C++ compiled program cannot because it can query the machine. It can determine if the machine is Intel or AMD; Pentium 4, Core Solo, or Core Duo; or if supports SSE4, etc.
A C++ program has to be compiled beforehand usually with mixed optimizations so that it runs decently well on all machines, but is not optimized as much as it could be for a single configuration (i.e. processor, instruction set, other hardware).
Additionally certain language features allow the compiler in C# and Java to make assumptions about your code that allows it to optimize certain parts away that just aren't safe for the C/C++ compiler to do. When you have access to pointers there's a lot of optimizations that just aren't safe.
Also Java and C# can do heap allocations more efficiently than C++ because the layer of abstraction between the garbage collector and your code allows it to do all of its heap compression at once (a fairly expensive operation).
Now I can't speak for Java on this next point, but I know that C# for example will actually remove methods and method calls when it knows the body of the method is empty. And it will use this kind of logic throughout your code.
So as you can see, there are lots of reasons why certain C# or Java implementations will be faster.
Now this all said, specific optimizations can be made in C++ that will blow away anything that you could do with C#, especially in the graphics realm and anytime you're close to the hardware. Pointers do wonders here.
So depending on what you're writing I would go with one or the other. But if you're writing something that isn't hardware dependent (driver, video game, etc), I wouldn't worry about the performance of C# (again can't speak about Java). It'll do just fine.
One the Java side, @Swati points out a good article:
https://www.ibm.com/developerworks/library/j-jtp09275
Other Answers
Answered Oct 04, 2011 · 197 votes
JIT vs. Static Compiler
As already said in the previous posts, JIT can compile IL/bytecode into native code at runtime. The cost of that was mentionned, but not to its conclusion:
JIT has one massive problem is that it can't compile everything: JIT compiling takes time, so the JIT will compile only some parts of the code, whereas a static compiler will produce a full native binary: For some kind of programs, the static compiler will simply easily outperform the JIT.
Of course, C# (or Java, or VB) is usually faster to produce viable and robust solution than is C++ (if only because C++ has complex semantics, and C++ standard library, while interesting and powerful, is quite poor when compared with the full scope of the standard library from .NET or Java), so usually, the difference between C++ and .NET or Java JIT won't be visible to most users, and for those binaries that are critical, well, you can still call C++ processing from C# or Java (even if this kind of native calls can be quite costly in themselves)...
C++ metaprograming
Note that usually, you are comparing C++ runtime code with its equivalent in C# or Java. But C++ has one feature that can outperform Java/C# out of the box, that is template metaprograming: The code processing will be done at compilation time (thus, increasing vastly compilation time), resulting into zero (or almost zero) runtime.
I have yet so see a real life effect on this (I played only with concepts, but by then, the difference was seconds of execution for JIT, and zero for C++), but this is worth mentioning, alongside the fact template metaprograming is not trivial...
Edit 2011-06-10: In C++, playing with types is done at compile time, meaning producing generic code which calls non-generic code (e.g. a generic parser from string to type T, calling standard library API for types T it recognizes, and making the parser easily extensible by its user) is very easy and very efficient, whereas the equivalent in Java or C# is painful at best to write, and will always be slower and resolved at runtime even when the types are known at compile time, meaning your only hope is for the JIT to inline the whole thing.
...
Edit 2011-09-20: The team behind Blitz++ (Homepage, Wikipedia) went that way, and apparently, their goal is to reach FORTRAN's performance on scientific calculations by moving as much as possible from runtime execution to compilation time, via C++ template metaprogramming. So the "I have yet so see a real life effect on this" part I wrote above apparently does exist in real life.
Native C++ Memory Usage
C++ has a memory usage different from Java/C#, and thus, has different advantages/flaws.
No matter the JIT optimization, nothing will go has fast as direct pointer access to memory (let's ignore for a moment processor caches, etc.). So, if you have contiguous data in memory, accessing it through C++ pointers (i.e. C pointers... Let's give Caesar its due) will goes times faster than in Java/C#. And C++ has RAII, which makes a lot of processing a lot easier than in C# or even in Java. C++ does not need using to scope the existence of its objects. And C++ does not have a finally clause. This is not an error.
:-)
And despite C# primitive-like structs, C++ "on the stack" objects will cost nothing at allocation and destruction, and will need no GC to work in an independent thread to do the cleaning.
As for memory fragmentation, memory allocators in 2008 are not the old memory allocators from 1980 that are usually compared with a GC: C++ allocation can't be moved in memory, true, but then, like on a Linux filesystem: Who needs hard disk defragmenting when fragmentation does not happen? Using the right allocator for the right task should be part of the C++ developer toolkit. Now, writing allocators is not easy, and then, most of us have better things to do, and for the most of use, RAII or GC is more than good enough.
Edit 2011-10-04: For examples about efficient allocators: On Windows platforms, since Vista, the Low Fragmentation Heap is enabled by default. For previous versions, the LFH can be activated by calling the WinAPI function HeapSetInformation). On other OSes, alternative allocators are provided (see https://secure.wikimedia.org/wikipedia/en/wiki/Malloc for a list)
Now, the memory model is somewhat becoming more complicated with the rise of multicore and multithreading technology. In this field, I guess .NET has the advantage, and Java, I was told, held the upper ground. It's easy for some "on the bare metal" hacker to praise his "near the machine" code. But now, it is quite more difficult to produce better assembly by hand than letting the compiler to its job. For C++, the compiler became usually better than the hacker since a decade. For C# and Java, this is even easier.
Still, the new standard C++0x will impose a simple memory model to C++ compilers, which will standardize (and thus simplify) effective multiprocessing/parallel/threading code in C++, and make optimizations easier and safer for compilers. But then, we'll see in some couple of years if its promises are held true.
C++/CLI vs. C#/VB.NET
Note: In this section, I am talking about C++/CLI, that is, the C++ hosted by .NET, not the native C++.
Last week, I had a training on .NET optimization, and discovered that the static compiler is very important anyway. As important than JIT.
The very same code compiled in C++/CLI (or its ancestor, Managed C++) could be times faster than the same code produced in C# (or VB.NET, whose compiler produces the same IL than C#).
Because the C++ static compiler was a lot better to produce already optimized code than C#'s.
For example, function inlining in .NET is limited to functions whose bytecode is less or equal than 32 bytes in length. So, some code in C# will produce a 40 bytes accessor, which won't be ever inlined by the JIT. The same code in C++/CLI will produce a 20 bytes accessor, which will be inlined by the JIT.
Another example is temporary variables, that are simply compiled away by the C++ compiler while still being mentioned in the IL produced by the C# compiler. C++ static compilation optimization will result in less code, thus authorizes a more aggressive JIT optimization, again.
The reason for this was speculated to be the fact C++/CLI compiler profited from the vast optimization techniques from C++ native compiler.
Conclusion
I love C++.
But as far as I see it, C# or Java are all in all a better bet. Not because they are faster than C++, but because when you add up their qualities, they end up being more productive, needing less training, and having more complete standard libraries than C++. And as for most of programs, their speed differences (in one way or another) will be negligible...
Edit (2011-06-06)
My experience on C#/.NET
I have now 5 months of almost exclusive professional C# coding (which adds up to my CV already full of C++ and Java, and a touch of C++/CLI).
I played with WinForms (Ahem...) and WCF (cool!), and WPF (Cool!!!! Both through XAML and raw C#. WPF is so easy I believe Swing just cannot compare to it), and C# 4.0.
The conclusion is that while it's easier/faster to produce a code that works in C#/Java than in C++, it's a lot harder to produce a strong, safe and robust code in C# (and even harder in Java) than in C++. Reasons abound, but it can be summarized by:
- Generics are not as powerful as templates (try to write an efficient generic Parse method (from string to T), or an efficient equivalent of boost::lexical_cast in C# to understand the problem)
- ["RAII remains unmatched (GC still can leak (yes, I had to handle that problem) and will only handle memory. Even C#'s using "," is not as easy and powerful because writing a correct Dispose implementations is difficult)"]
- ["C# readonly "," and Java final "," are nowhere as useful as C++'s const "," (There's no way you can expose readonly complex data (a Tree of Nodes, for example) in C# without tremendous work, while it's a built-in feature of C++. Immutable data is an interesting solution, but not everything can be made immutable, so it's not even enough, by far)."]
So, C# remains an pleasant language as long as you want something that works, but a frustrating language the moment you want something that always and safely works.
Java is even more frustrating, as it has the same problems than C#, and more: Lacking the equivalent of C#'s using keyword, a very skilled colleague of mine spent too much time making sure its resources where correctly freed, whereas the equivalent in C++ would have been easy (using destructors and smart pointers).
So I guess C#/Java's productivity gain is visible for most code... until the day you need the code to be as perfect as possible. That day, you'll know pain. (you won't believe what's asked from our server and GUI apps...).
About Server-side Java and C++
I kept contact with the server teams (I worked 2 years among them, before getting back to the GUI team), at the other side of the building, and I learned something interesting.
Last years, the trend was to have the Java server apps be destined to replace the old C++ server apps, as Java has a lot of frameworks/tools, and is easy to maintain, deploy, etc. etc..
...Until the problem of low-latency reared its ugly head the last months. Then, the Java server apps, no matter the optimization attempted by our skilled Java team, simply and cleanly lost the race against the old, not really optimized C++ server.
Currently, the decision is to keep the Java servers for common use where performance while still important, is not concerned by the low-latency target, and aggressively optimize the already faster C++ server applications for low-latency and ultra-low-latency needs.
Conclusion
Nothing is as simple as expected.
Java, and even more C#, are cool languages, with extensive standard libraries and frameworks, where you can code fast, and have result very soon.
But when you need raw power, powerful and systematic optimizations, strong compiler support, powerful language features and absolute safety, Java and C# make it difficult to win the last missing but critical percents of quality you need to remain above the competition.
It's as if you needed less time and less experienced developers in C#/Java than in C++ to produce average quality code, but in the other hand, the moment you needed excellent to perfect quality code, it was suddenly easier and faster to get the results right in C++.
Of course, this is my own perception, perhaps limited to our specific needs.
But still, it is what happens today, both in the GUI teams and the server-side teams.
Of course, I'll update this post if something new happens.
Edit (2011-06-22)
"We find that in regards to performance, C++ wins out by a large margin. However, it also required the most extensive tuning efforts, many of which were done at a level of sophistication that would not be available to the average programmer.
[...] The Java version was probably the simplest to implement, but the hardest to analyze for performance. Specifically the effects around garbage collection were complicated and very hard to tune."
Sources:
- https://days2011.scala-lang.org/sites/days2011/files/ws3-1-Hundt.pdf
- http://www.computing.co.uk/ctg/news/2076322/-winner-google-language-tests
Edit (2011-09-20)
"The going word at Facebook is that 'reasonably written C++ code just runs fast,' which underscores the enormous effort spent at optimizing PHP and Java code. Paradoxically, C++ code is more difficult to write than in other languages, but efficient code is a lot easier [to write in C++ than in other languages]."
– Herb Sutter at //build/, quoting Andrei Alexandrescu
Sources:
- http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T
- http://video.ch9.ms/build/2011/slides/TOOL-835T_Sutter.pptx
Other Answers
Answered Dec 07, 2011 · 48 votes
Whenever I talk managed vs. unmanaged performance, I like to point to the series Rico (and Raymond) did comparing C++ and C# versions of a Chinese/English dictionary. This google search will let you read for yourself, but I like Rico's summary.
So am I ashamed by my crushing defeat? Hardly. The managed code got a very good result for hardly any effort. To defeat the managed Raymond had to:
- Write his own file I/O stuff
- Write his own string class
- Write his own allocator
- Write his own international mapping
Of course he used available lower level libraries to do this, but that's still a lot of work. Can you call what's left an STL program? I don't think so, I think he kept the std::vector class which ultimately was never a problem and he kept the find function. Pretty much everything else is gone.
So, yup, you can definately beat the CLR. Raymond can make his program go even faster I think.
Interestingly, the time to parse the file as reported by both programs internal timers is about the same -- 30ms for each. The difference is in the overhead.
For me the bottom line is that it took 6 revisions for the unmanaged version to beat the managed version that was a simple port of the original unmanaged code. If you need every last bit of performance (and have the time and expertise to get it), you'll have to go unmanaged, but for me, I'll take the order of magnitude advantage I have on the first versions over the 33% I gain if I try 6 times.
4/5
Top Answer
Answered May 14, 2011 · 3 votes
H2Pas is a popular tool to convert C headers to Pascal. I don't know of any to actually convert C code to Pascal code though.
From a quick google search, I see several that may or may not be good:
- http://cc.embarcadero.com/item/23991
- http://c2pas.sourceforge.net/
I am tempted to say you'll have to do a lot of it by hand one way or another.
5/5
www.geeksforgeeks.org › how-to-design-databaseHow to Design Database Inventory Management Systems
www.geeksforgeeks.org › how-to-design-databaseApr 30, 2024 · Database Design Essentials for Inventory Management Systems. Designing a robust database for an Inventory Management System entails careful consideration of several key factors such as data structure, indexing, query optimization, and data integrity.
duckdb.org › docs › apiADBC API – DuckDB
duckdb.org › docs › api2 days ago · We begin our C++ example by declaring the essential variables for querying data through ADBC. These variables include Error, Database, Connection, Statement handling, and an Arrow Stream to transfer data between DuckDB and the application.
People also ask
How do I design a robust database for an inventory management system?
- Designing a robust database for an Inventory Management System entails careful consideration of several key factors such as data structure, indexing, query optimization, and data integrity.
How to Design Database Inventory Management Systems
www.geeksforgeeks.org/how-to-design-database-inventory-management-systems/How do I design a database for an inventory management system?
- Scalability: Design the database with scalability in mind to accommodate future growth and expansion of the inventory management system. Designing a database for an Inventory Management System requires careful consideration of entities, attributes, relationships, and database design principles.
How to Design Database Inventory Management Systems
www.geeksforgeeks.org/how-to-design-database-inventory-management-systems/Why is a database important for inventory management?
- A well-designed database not only ensures data accuracy but also contributes to the overall efficiency and effectiveness of inventory management processes, enabling organizations to optimize their inventory operations and meet customer demands effectively.
How to Design Database Inventory Management Systems
www.geeksforgeeks.org/how-to-design-database-inventory-management-systems/What is an inventory management system?
- Inventory Management Systems encompass a range of features designed to streamline inventory tracking, ordering, replenishment, and reporting. These features typically include: Inventory Tracking: Monitoring the movement and status of inventory items in real time, including stock levels, locations, and transaction history.
How to Design Database Inventory Management Systems
www.geeksforgeeks.org/how-to-design-database-inventory-management-systems/www.geeksforgeeks.org › how-to-get-raw-sql-outputHow to Get Raw SQL Output from the Query Builder?
www.geeksforgeeks.org › how-to-get-raw-sql-output1 day ago · 5. Getting the Raw SQL Output. To get the raw SQL output from the query builder, you can use the str () function or SQLAlchemy’s compile method. # Using str () functionprint (str (query))# Using compile () methodcompiled_query = query.compile (engine)print (compiled_query)
www.geeksforgeeks.org › difference-between-aDifference between a Distributed Lock Manager and a ...
www.geeksforgeeks.org › difference-between-a5 days ago · The primary objective of a distributed database is to ensure data consistency and availability. Complexity. Distributed lock managers are less complex as they do not handle data storage functions. Distributed databases are more complex due to the need for data management across locations. Operational Dependency.
devblogs.microsoft.com › ai-and-azure-sql-databaseCoding at the Speed of Innovation: AI and more with Azure SQL ...
devblogs.microsoft.com › ai-and-azure-sql-databaseMay 17, 2024 · For an example, see AzureSQL_CogSearch_IntegratedVectorization, a sample notebook for a simple product recommendation application based on a database of user reviews. This sample is a great example of how built-in AI support makes it easy to build intelligent applications with Azure SQL Database.
access-templates.com121+ Microsoft Access Databases And Templates With Free ...
access-templates.comMay 19, 2024 · Download multi-purpose database examples of Microsoft access templates here. Get free MS Access templates for small business company and inventory database, non profit organization, employee database, and personal student database.
duckdb.org › docs › apiC++ API – DuckDB
duckdb.org › docs › api3 days ago · Basic API Usage DuckDB implements a custom C++ API. This is built around the abstractions of a database instance (DuckDB class), multiple Connections to the database instance and QueryResult instances as the result of queries. The header file for the C++ API is duckdb.hpp. The standard source distribution of libduckdb contains an ...
Searches related to microsoft access sample inventory database example java c++
