0
What else can I help you with?
Java does not support pointers then what is null pointer exception?
A null pointer exception is thrown when you are trying to manipulate an object that is null. It is just the name and does not have any relevance to the pointers as in C Example: ArrayList lst = null; Object obj = lst.get(0); In the first line we have declared an array list. Without initializing it we have tried to access the element in the 0th position. This would cause a null pointer exception.
What is unchecked exception?
A checked exception is an exception which the Java source code must deal with, either by catching it or declaring it to be thrown. Unchecked exceptions are all exceptions which do not follow this rule. When an unchecked exception is thrown, it is usually caused by a misuse of code - passing a null or otherwise incorrect argument. This includes classes like NullPointerException and IllegalArgumentException. Checked exceptions are generally caused by faults outside of the code itself - missing resources, networking errors, and problems with threads come to mind. These could include subclasses of FileNotFoundException, UnknownHostException, etc. The Java documentation (link below) gives some loose guidelines to follow when trying to decide which type of exception to use: "If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception." From a purely code-oriented point of view, a checked exception is a subclass of Exception, while an unchecked exception is a subclass of RuntimeException.
Passing an array name to a pointer assigns the first memory location of the array to the pointer variable?
Yes, passing an array name to a pointer assigns the first memory location of the array to the pointer variable. An array name is the same as a pointer to the first location of the array, with the exception that an array name is a r-value, while a pointer is an l-value.
What is a file pointer?
A file pointer is an opaque object that refers to a file. Opaque means that you should not attempt to delve into its specific value, other than to use it as a file pointer. FILE *fp; /* fp is the file pointer */ fp = fopen("somefile.txt"); if (fp == NULL) ...{exception}... fprintf(fp, "Hello somefile.txt"); fclose(fp);
What is thread exception?
In computer terminology, the thread refers to the sequence of instructions that have been executed. When the computer reaches a decision point (if x > 1), the thread may take either of two paths. An "exception" simply means that something happened that was not expected or something that resulted in an unpredictable outcome. Effectively, a thread exception means that the computer ended up in an unexpected section of code. Thread exceptions can often be the result of pointer errors.
Java does not support pointers then what is null pointer exception?
A null pointer exception is thrown when you are trying to manipulate an object that is null. It is just the name and does not have any relevance to the pointers as in C Example: ArrayList lst = null; Object obj = lst.get(0); In the first line we have declared an array list. Without initializing it we have tried to access the element in the 0th position. This would cause a null pointer exception.
What is unchecked exception?
A checked exception is an exception which the Java source code must deal with, either by catching it or declaring it to be thrown. Unchecked exceptions are all exceptions which do not follow this rule. When an unchecked exception is thrown, it is usually caused by a misuse of code - passing a null or otherwise incorrect argument. This includes classes like NullPointerException and IllegalArgumentException. Checked exceptions are generally caused by faults outside of the code itself - missing resources, networking errors, and problems with threads come to mind. These could include subclasses of FileNotFoundException, UnknownHostException, etc. The Java documentation (link below) gives some loose guidelines to follow when trying to decide which type of exception to use: "If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception." From a purely code-oriented point of view, a checked exception is a subclass of Exception, while an unchecked exception is a subclass of RuntimeException.
What happens when null pointer is released?
Undefined behavior. Literally anything can happen. ------------------------------------------------------------------ And does with one exception that I know of, DJGPP (for DOS). Obviously before freeing a pointer it is tested for being NULL.
Passing an array name to a pointer assigns the first memory location of the array to the pointer variable?
Yes, passing an array name to a pointer assigns the first memory location of the array to the pointer variable. An array name is the same as a pointer to the first location of the array, with the exception that an array name is a r-value, while a pointer is an l-value.
What is a file pointer?
A file pointer is an opaque object that refers to a file. Opaque means that you should not attempt to delve into its specific value, other than to use it as a file pointer. FILE *fp; /* fp is the file pointer */ fp = fopen("somefile.txt"); if (fp == NULL) ...{exception}... fprintf(fp, "Hello somefile.txt"); fclose(fp);
What is thread exception?
In computer terminology, the thread refers to the sequence of instructions that have been executed. When the computer reaches a decision point (if x > 1), the thread may take either of two paths. An "exception" simply means that something happened that was not expected or something that resulted in an unpredictable outcome. Effectively, a thread exception means that the computer ended up in an unexpected section of code. Thread exceptions can often be the result of pointer errors.
Describe the JAVA throwable class hierarchy and types of exceptions?
In Java there are two main types of Exceptions. * Checked Exceptions - The ones that can be checked & handled in our code. Ex: I/O Exception, SQL Exception etc. In most cases, the compiler itself forces us to catch & handle these exceptions * Un-checked Exceptions - The ones that we cannot & should not handle in our code. Ex. Null Pointer Exception The java.lang.Throwable is the super class of all errors and exceptions in Java. Only objects of this class can be thrown & caught and handled by try-catch blocks. Ex: try { ..... ..... } catch (Exception e){ ... } finally { ... }
Java null pointer exceptions?
A null pointer exception in java comes when you are trying to perform any action on an object that isnt initialized/has a value i.e., is a NULL Value Ex: private String s; //declare a string if(s.equals("test")){ //do something.. } You will get a null pointer in the if condition because you are checking a value that is null which is not allowed..
Can you describe how Exception Handling is implemented in C plus plus?
Exception handling is a programming language construct or computer hardware mechanism designed to handle the occurrence of exceptions, special conditions that change the normal flow of program execution
Explain the allocation of memory cells when a function is called?
When you call a function, the stack pointer is adjusted to cater for the function's arguments (if any), the caller's return address (mandatory), the function's local variables (if any) and the function's exception handlers (if any).
How to handle derived class exception in c plus plus?
Before we look at how to handle an exception in a derived class, it is important that you understand what happens when an exception is thrown. As soon as an exception is thrown, the call stack immediately unwinds until a suitable handler for the exception is found. If no handler is found and the call stack is completely unwound back to the main function, the application terminates with an unhandled exception. By way of an example, consider the following: #include<iostream> #include<exception> #include<memory> struct A { A () { std::cout << "Construct\tA\n"; } ~A () { std::cout << "Destruct\tA\n"; } virtual void do_something(int i) = 0; }; struct B : A { B () { std::cout << "Construct\tB\n"; } ~B () { std::cout << "Destruct\tB\n"; } void do_something(int i) override; }; void B::do_something (int i) { std::cout << "Begin B::do_something(" << i << ")\n"; if (!i) throw std::range_error ("B::do_something(int) : argument must be non-zero!"); std::cout << "End B::do_something(" << i << ")\n"; } void caller() { std::cout << "Begin caller()\n"; B* b = new B; for (int i=-5; i<=5; ++i) b->do_something (i); delete b; std::cout << "End caller()\n"; } int main() { std::cout << "Begin main()\n"; caller(); std::cout << "End main()\n"; } When you execute this code, you will see the following output: Begin main() Begin caller() Construct A Construct B Begin B::do_something(-5) End B::do_something(-5) Begin B::do_something(-4) End B::do_something(-4) Begin B::do_something(-3) End B::do_something(-3) Begin B::do_something(-2) End B::do_something(-2) Begin B::do_something(-1) End B::do_something(-1) Begin B::do_something(0) The program terminates at this point with an unhandled exception. The trace code obviously gives us an idea of where the exception occurred however the purpose of the trace code is not to track down the problem, it is merely to highlight the flow of execution (in real code we may not have access to any trace code at all). If we place a catch-all exception handler in main(), we can get a better idea of what the problem is: int main() { std::cout << "Begin main()\n"; try { caller(); } catch (...) // catch-all { try { std::exception_ptr eptr = std::current_exception(); std::rethrow_exception (eptr); } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } } std::cout << "End main()\n"; } Note the use of a nested try-catch in the catch-all. This is required because we have no way of knowing what type of exception we're actually dealing with in the catch-all. We first obtain an exception pointer to the current exception and then re-throw that pointer. This creates a standard exception which we can catch and handle normally. Now we get the following output: Begin main() Begin caller() Construct A Construct B Begin B::do_something(-5) End B::do_something(-5) Begin B::do_something(-4) End B::do_something(-4) Begin B::do_something(-3) End B::do_something(-3) Begin B::do_something(-2) End B::do_something(-2) Begin B::do_something(-1) End B::do_something(-1) Begin B::do_something(0) Exception: B::do_something(int) : argument must be non-zero! End main() The program appears to exit normally so you might think that we could feasibly keep this program running now that we've handled the exception. But we cannot. We haven't actually handled the exception at all we've simply logged the problem at this stage. From the trace output we can see that derived object B was constructed, but it was not destroyed. More importantly, the pointer we used to construct that object no longer exists: it was local to the caller() function and that fell from scope the moment we entered the catch-all in main(). The pointer is gone but the B object it pointed to still exists in memory (as does its base class A). in other words, we've created a resource leak. If nothing else, this example should demonstrate quite clearly why we must never use raw pointers to dynamically allocated memory in C++. Even though we have a catch-all in main(), we have no way to recover resources allocated between main() and the point at which the exception was thrown, so the only option is to exit the program at this point. The best way to avoid leaked resources is to use a resource handle instead of raw pointers. That is, if we use a statically-allocated object that encapsulates a raw pointer, we get the benefit of dynamic allocation and automatic recovery in the event of an exception. Consider the following alternative implementation of our caller() function: void caller() { std::cout << "Begin caller()\n"; std::unique_ptr<B> b {new B}; for (int i=-5; i<=5; ++i) b->do_something (i); std::cout << "End caller()\n"; } The std::unique_ptr class is a smart pointer. It behaves just like a raw pointer but we no longer need to explicitly delete the pointer; the smart pointer does that for us automatically as soon as it falls from scope. Indeed, if we try to explicitly delete a smart pointer, we'd get a compiler error. Remember that a smart pointer is not a pointer at all, it just behaves like one. If we run the program again, we see the following output: Begin main() Begin caller() Construct A Construct B Begin B::do_something(-5) End B::do_something(-5) Begin B::do_something(-4) End B::do_something(-4) Begin B::do_something(-3) End B::do_something(-3) Begin B::do_something(-2) End B::do_something(-2) Begin B::do_something(-1) End B::do_something(-1) Begin B::do_something(0) Destruct B Destruct A Exception: B::do_something(int) : argument must be non-zero! End main() As you can see, our B object now destroys itself automatically (along with the base class A). Now we're in a better position to make a full recovery from the exception and deal with it properly.
How do you notify an error occured within the constructor of a class?
Throw an exception. In some cases it may be possible to handle the error from within the constructor body, however if the error is such that we cannot construct a valid object, then we must throw an exception back to the caller.Exceptions work in conjunction with "resource acquisition is initialisation" (RAII). When a constructor throws an exception, all resources acquired by the constructor up to that point must be released.Consider the following:class time_bomb {private:int* counter;public:time_bomb (int count): counter {new int (count)} { if(!count) throw std::exception ("invalid argument"); }~time_bomb (void) { delete counter; }// ...};Here we are giving our time_bomb an invariant in that its counter value must be non-zero at the point of construction. If we attempt to construct a time_bomb with the value zero then we treat that as being an "exceptional circumstance"; the invariant cannot be established and the fault clearly lies with the caller. So we throw an exception to alert the caller that it was not possible to construct the time_bomb.During construction, our object only exists to the extent that it is partially constructed. An object only becomes valid when we return from the constructor, whether via an explicit return statement within the constructor's body or simply by "falling off" the end of the constructor body. If an exception occurs during construction, the destructors for all member objects and base classes constructed up to that point are automatically invoked and the object ceases to exist.When the exception is thrown, the call stack unwinds and the time_bomb's counter member falls from scope. But the resource it referred to remains in memory because pointers are not objects and therefore don't have destructors. The time_bomb's own destructor (which would normally release the counter's resource) cannot be invoked because the time_bomb ceased to exist the moment we threw an exception.Thus if an exception is thrown, we create a memory leak.There are three ways to resolve this problem. The first is to simply release the resource prior to throwing the exception:time_bomb::time_bomb (int count): counter {new int (count)} {if(!count) {delete counter;throw std::exception ("invalid argument");}}The second solution is to delay resource acquisition until after checking the invariant:time_bomb::time_bomb (int count): counter {nullptr} { if(!count) throw std::exception ("invalid argument");counter = new int (count);}Neither of these solutions is satisfactory. If we get into the habit of choosing the first solution, we will inevitably end up creating a class where we "forget" to explicitly release a resource, particularly if the class acquires many resources. And if we choose the second solution, we incur a performance penalty because we are no longer initialising members at the point of instantiation, we are instantiating and then later initialising via assignment which requires two separate operations.The correct solution is to use a resource handle to manage the resource for us:class time_bomb {private:std::unique_ptr counter;public:time_bomb (int count): counter {new int (count)} {if(!count) throw std::exception ("invalid argument"); }// ...};The counter member is now an object (a smart pointer) rather than a "naked" pointer. When a smart pointer falls from scope or is explicitly destroyed, it automatically releases the resource it refers to. Thus when an exception is thrown by the constructor, the smart pointer is implicitly destroyed, thus releasing the resource.Note also that we no longer need to declare a destructor in our time_bomb. Using RAII (via resource handles or smart pointers) greatly simplifies our code; we are far less likely to "forget" to release resources when it is done automatically for us.
