Animals & Plants Arts & Entertainment Auto Beauty & Health Books and Literature Business Electronics Engineering & Technology Food & Drink History Hobbies Jobs & Education Law & Government Math People & Society Science Social Studies Sports Travel & Places

📱

C++ Programming

Questions related to the C++ Computer Programming Language. This ranges all the way from K&R C to the most recent ANSI incarnations of C++, including advanced topics such as Object Oriented Design and Programming, Standard Template Library, and Exceptions. C++ has become one of the most popular languages today, and has been used to write all sort of things for nearly all of the modern operating systems and applications." It it a good compromise between speed, advanced power, and complexity.

2,546 Questions

C++ Programming

What is the signature of a function in c plus plus?

Asked by PCForrest

A function's signature is defined by the number and type of parameters. Functions with the same signature cannot differ by return type alone. Use of the const keyword also constitutes part of the signature.

C++ Programming

Math and Arithmetic

What is 1234 plus 5678?

Asked by Anonymous

1234 plus 5678 equals 6912

Computer Programming

C++ Programming

What is the need for oops paradigm?

Asked by Greeshmasri17

Object oriented programming is a concept that was created because of the need to overcome the problems that were found with using structured programming techniques. While structured programming uses an approach which is top down, OOP uses an approach which is bottom up. Traditionally, programming has placed an emphasis on logic and actions.

Object oriented programming has taken a completely different direction, and will place an emphasis on objects and information. With object oriented programming, a problem will be broken down into a number of units. These units are called objects. The foundation of OOP is the fact that it will place an emphasis on objects and classes.

Objects will be defined, and they will interact inside the system in a number of different ways. There are a number of advantages to be found with using the OOP paradigm, and some of these are simple maintenance, an advanced analysis of complicated programs, and reusability. There are a number of programming languages that use OOP, and some of these are Java, C++, and Ada. One concept that you will want to become familiar with is data modeling. Before you can construct an object oriented system, you will first need to find the objects within the system and determine the relationships they have. This process is called data modeling. There are some other OOP terms that you will want to know.

A class is a unit that holds data and functions which will carry out operations on the data. A class will be comprised of three access modifiers. These three modifiers are protected, private, and public. A member that is public can be accessed and inherited. A member that is designated as private cannot be accessed by objects that exist outside the system. In addition to this, it cannot be inherited. While a member who is protected can be inherited, they cannot be accessed by objects which reside outside of the class hierarchy. Another term that you will hear about often in OOP is objects.

An object is a state of class. It can receive and send messages to other objects, and it can handle data. The objects which exist within software are often based off real world objects, and will behave in the same manner. There are two things that are found with all objects that exist in the real world. These two things are behaviors and states. While behaviors and states are found in real world objects, they can also be found in software objects as well. Another OOP concept that you will need to know is a method. A method is a process that is used to handle an object. A method can be public, protected, or private. The visibility of the member will determine how much of it can be seen by outside objects.

Inheritance is an aspect of OOP that allows subclasses to inherit the traits and characteristics of its superclass. The subclass will inherit all members except those that designated as being private. The subclass may have a large number classes from multiple bases, and this concept is called Multiple Inheritance. It is possible for a subclass to use the behavior of the members it has inherited, and it can also add new members as well. There are two powerful advantages that inheritance has, and these are the implementation of abstract data and reusability.

Encapsulation is another important concept that you will need to know. In a nutshell, encapsulation is responsible for shielding the data within a class from outside objects. It will only reveal the functional information. However, the implementation will be hidden. Encapsulation is a concept which promotes modularity, and it is also crucial for hiding information.

C Programming

Algebra

C++ Programming

When to use inheritance in c plus plus?

Asked by Anonymous

You use inheritance whenever you need a more specialised version of an existing class (the base class). Rather than creating a new class entirely from scratch, and therefore duplicating tried and tested code, you simply build upon the existing class, overriding the existing methods and adding more specialised methods, whilst retaining all the generic functionality of the base class.

C++ Programming

How does member function of class define?

Asked by Anonymous

Static member functions (or static member methods) are local to the class in which they are declared but, unlike non-static member functions, they are not attached to any instance of the class. That is, they have no access to an implicit this pointer.

Static member functions are often used to declare global functions in conjunction with private static member variables. The variables are not global as they are only accessible to the class itself, but because they are static they exist for the lifetime of the application.

The best possible example of a static member function relates to singleton classes. A singleton class is typically a global class for which one instance (and one instance only) must be guaranteed to remain in scope for the entire duration of the program. A typical usage for such a class might be to enable logging (writing a log of all program activity), and we'd only need one logger.

This means we must actively prevent new instances from being created once the first instance is created, and must ensure it cannot be destroyed while the program is active, intentionally or otherwise. In order to achieve this, the default constructor, the copy constructor and the assignment operator must be declared private with no implementation. This then means that only the class itself can instantiate the one and only instance of the class, and the only way to achieve that is with a static member function and a static member variable.

The following demonstrates the skeleton of a singleton declaration. In a real-life singleton, you would design the remainder of the class just as you would an ordinary class, with instance variables and methods that permit it to carry out its role (whether as a logger or as some other global class for which only one instance is ever required). The example includes simple code to demonstrate its usage as a container for an int using dynamic memory.

Note how the static variable Singleton::instance is initialised to NULL outside of the class declaration (at file scope). This ensures correct initialisation at compile time. This line is typically placed in the class cpp file (implementation file), while the class declaration itself is placed in the class hpp file (header). The one and only instance of the Singleton class is created upon the first call to Singleton::Instance(), which returns a reference to the instance thus permitting access to the instance members.

Since the instance is static, it is guaranteed to remain in scope for the entire life-cycle of the program. It doesn't matter that the static Singleton::instance variable is instantiated dynamically but is never actually released. Since it is a static variable, the memory it points to will be released automatically when the program terminates. The same can also be said of the Singleton::instance->pointer member variable, but it's always good practice to release all non-static members in the private destructor.

The design is such that it would be impossible to inadvertently create two or more instances of the Singleton class, and impossible to destroy the one and only instance until the program terminates.

While there are many other examples of static member functions, the majority merely demonstrate usage that could be far better implemented as a non-static member function or even a friend function. Demonstrations of any practical merit are few and far between (although they do exist), but the Singleton usage is by far the most ingenious and practical usage you will encounter. Microsoft may not agree (a Microsoft singleton isn't strictly a singleton), but the framework shown below is tried and tested, is robust, and does exactly what it says on the tin!

#include

using namespace std;

class Singleton{

private:

Singleton():pointer(new int(100)){} // No creation outside the class.

Singleton(Singleton const&){} // No copying outside the class.

Singleton& operator=(Singleton const&){} // No assignment outside the class.

~Singleton(){delete(pointer);} // No destruction outside the class.

static Singleton* instance; // The only instance there can ever be.

int * pointer; // Dynamic memory allocation (for illustrative purpose).

public:

// Static member function:

static Singleton& Instance(){

if( !instance ) // Creates the instance on first usage only.

instance = new Singleton();

VERIFY(instance != NULL); // Not essential, but prudent.

return(*instance);

}

// A member function (for illustrative purposes).

void foo(void){

cout<<"Singleton::instance resides at memory address 0x"<

cout<<"Singleton::instance->pointer resides at memory address 0x"<

}

// A member accessor and mutator (for illustrative purposes).

int GetValue(void){return(*pointer);}

void SetValue(const int value){*pointer=value;}

};

// Static member initialisation (occurs at compile time). Not optional!

Singleton* Singleton::instance = NULL;

int main(void)

{

// Call singleton methods:

Singleton::Instance().foo(); // The one and only instance is instantiated at this point, just prior to calling foo().

Singleton::Instance().SetValue(3); // Mutate the member variable.

Singleton::Instance().foo(); // Call foo() again.

Singleton::Instance().SetValue(15); // Mutate the member variable.

// Call the member variable accessor:

cout<<"Singleton variable: "<

// It is not possible to delete the instance by accident (the destructor is inaccessible outside of the class):

//delete(&Singleton::Instance()); // Causes compiler error C2248! (MSVC++).

return( 0 );

}

C++ Programming

What are virtual constructors or destructors?

Asked by Anonymous

If an object (with a non-virtual destructor) is destroyed explicitly by applying the delete operator to a base-class pointer to the object, the base-class destructor function (matching the pointer type) is called on the object. There is a simple solution to this problem

Computer Programming

C Programming

C++ Programming

How do you insert a node using doubly linked list in c plus plus?

Asked by Anonymous

#include<iostream>

#include<list>

void print_list (std::list<int>& list)

{

for (std::list<int>::const_iterator it=list.begin(); it!=list.end(); ++it)

std::cout << *it << ", ";

std::cout << "\b\b \n";

}

int main()

{

// instantiate a list

std::list<int> list;

// push a new value onto the back of the list:

list.push_back (1);

print_list (list);

// push a new value onto the front of the list:

list.push_front (2);

print_list (list);

// insert a new value at the back of the list

list.insert (list.end(), 3);

print_list (list);

// insert a new value at the front of the list

list.insert (list.begin(), 4);

print_list (list);

// locate value 1.

std::list<int>::const_iterator it=list.begin();

while (it!=list.end() && *it != 1)

++it;

// insert a new value in front of value 1.

list.insert (it, 5);

print_list (list);

}

Output:

2, 1

2, 1, 3

4, 2, 1, 3

4, 2, 5, 1, 3

Computer Programming

C Programming

C++ Programming

Which is easier 'C' or 'C plus plus'?

Asked by Anonymous

Opinion 1:

I think both are easy to use an manipulate although i have never written a c++ program other than hello world but to know c++ you have to know c and c is a standard high level language which is easy to grasp

Opinion 2:

C++ is easier in the end because it is a revised version of the old c language. It is not required to learn C first before learning C++ because you pick up bad habits and when you move to C++, those habits will be hard to get rid of. C++ is a lot more powerful and accurate, it is harder at first but with time it will be a lot easier and more organized than c.

In conclusion, C is easier to learn but not recommended to learn.

I highly recommend people to go straight to C++ to pick up only good habits, then go back to C if you're curious how it works.

C Programming

C++ Programming

Write a program in c to print a mark sheet?

Asked by Anonymous

import java.util.*;

import java.lang.String;

import java.io.*;

import java.util.Date;

import java.util.Timer;

class project

{

public static void main(String args[]) throws IOException

{

String sub1,sub2,sub3,sub4,sub5,sub6;

String name,sem;

int m1,m2,m3,m4,m5,m6,m7;

//Date dt = new Date(now.getTime()

int prn_no,seat_no,total;

float per;

float temp;

String msg="*";

long currentTimeInMillis = System.currentTimeMillis();

Date today = new Date( currentTimeInMillis );

Scanner in=new Scanner(System.in);

BufferedReader b=new BufferedReader(new InputStreamReader(System.in));

System.out.println("Enter name of student=");

name=b.readLine();

System.out.println("Enter prn number =");

prn_no=in.nextInt();

System.out.println("Enter name of semester=");

sem=b.readLine();

System.out.println("Enter Roll number =");

seat_no=in.nextInt();

System.out.println("Enter first subject name =");

sub1=b.readLine();