C++ Programming

C++ does not have a built-in kilometre class. If you have such a class, it was provided for you by a third party. However, your IDE should be able to show you the members, including private members. I'd imagine such a class would have a private float or double member to store the actual number of kilometres it represents, and perhaps some public methods to convert the number to other formats, such as millimetres, centimetres, miles, yards, inches, etc.

No, accessor member functions are a sign of good class design, particularly in terms of data encapsulation.

Default arguments are function parameters for which a default value is implied when not explicitly stated.

int foo(int x, int base=10 ) {

return( x%base); }

The above function assumes 'base' is 10 unless you specify otherwise when making the call. Thus calling foo(15) will return 5, as will foo(5,10), but foo(15,16) will return 15.

Note that default parameters must appear after all non-default parameters in a function declaration. Once you specify a default parameter, all other parameters that follow must also have default values.

Note also that when the definition of a function is split from its declaration, only the declaration should declare the default parameters:

// Declaration:

int foo(int x, int base=10 );

// Definition:

int foo(int x, int base ) {

return( x%base); }

You write it exactly the same as you would write it in any other verions of C++, by taking user input to determine the three sides of your triangle. In other words, input three real numbers. What you do with those three numbers is entirely up to you, but presumably you'd want to calculate the angles of a triangle given the length of its three sides. For that you would need to use the cosine rule which states that for any triangle with angles A, B and C whose opposing sides are a, b and c respectively, cos A = (b2 + c2 - a2)/2bc and cos B = (c2 + a2 - b2)/2ca. Knowing two angles, A and B, you can easily work out that angle C must be 180 - (A + B).

Firstly you must determine the longest string in the list and allocate an array to accommodate it. This may incur a lot of wasted memory, especially if you have a particularly long string amongst hundreds or thousands of very short strings. A more efficient method would be to create a one-dimensional array of pointers to null-terminated strings. This has the advantage that you do not need to copy or move the strings, only the pointers need be sorted, and the strings can reside anywhere in memory -- they needn't be in contiguous memory as they would in a two-dimensional character array.

Regardless, once you've got your array, there are many different algorithms you can employ to sort it. Some are better than others. For short lists up to perhaps 20 items, a Bubble Sort is ideal and is by far the simplest to implement. For larger lists, you should consider more efficient sorting algorithms, such as Quick Sort and Merge Sort. See the related link below for a comprehensive list and table of comparisons. You will also find example code and full explanations on each algorithm, including pros and cons of each.

The rand() function returns an integer (int) value that represents a pseudo-random number between 0 and RAND_MAX, RAND_MAX being a constant declared in the run-time library. Each time rand() is invoked, a different value is returned.

If all objects are the same length, divide the size of the file by the size of an object. If the objects are variable length or different types of object, you must serialise the objects one at a time, counting them as you go. A better approach to counting is to maintain a count of stored objects in an user-defined header segment within the file, usually at the start of the file, or if dealing with mixed data types, store the length of each object before the data for each object, thus allowing you to quickly traverse the file without serialising.

The primary use of C is to write efficient, cross-platform, procedural code. It is much easier to write cross-platform machine code using C than it is to use assembly, since C also permits procedure calls and structured programming. C is regarded as a mid-level language, giving the benefits of low-level coding combined with high-level abstraction.

The primary use of C++ is to write efficient, cross-platform, object-oriented code. Object-oriented programming extends structured programming allowing highly-complex data to be modelled far more easily and more robustly than with structured languages. Since C++ evolved from C, you also gain the benefit of using C-style coding when required.

C is an excellent language for writing low-level code that would otherwise be written in assembly. This includes device drivers and operating system components. Major applications are typically written in C++.

Unlike C and C++, all built-in data types in C# are not implementation-defined, they are consistent across all implementations. An int always occupies 32-bits, thus the range of valid values is -2,147,483,648 to 2,147,483,647 inclusive.

Comments in C++ always begin with // and extend to the end of the line. Multi-line comments must have // on each line. Any text that follows this symbol up to the newline character is completely ignored by the compiler.

You can also use C-style comments, where multi-line comments can be enclosed within opening /* and closing */ markers. This type of comment can also be used to insert a short comment between C++ expressions upon the same line. Again, the compiler ignores everything, from the opening /* marker up to the closing */ marker.

All comments are stripped from your source during preprocessing, at the point where macros are processed (also known as precompilation). The resulting intermediate file is the file that is actually compiled.

C++ has no built-in graphics support whatsoever. C++ is a generic language designed to operate on a wide variety of hardware, including devices without graphics capability. Graphics are platform-specific, thus the code you use will be dependant upon the graphics API specific to your operating system and its hardware. Although you could use the text-based output of your console to draw and move a stick figure, the console was never intended to be used in this way and you'd actually find it a lot easier to use a proper graphics library, where line-drawing is greatly simplified by a huge range of abstract methods that exploit the low-level capabilities of your hardware.

Object initialisation is taken care of by the object's constructor(s). Initialisation is generally done during the initialisation stage of the constructor (immediately before the body of the constructor). Complex members such as pointers can be initialised to NULL in the initialisation stage. If new memory must be allocated to a member pointer, do it in the body of the constructor. Remember to clean up all allocated memory in the class destructor.

class cMyClass

{

public: // Construction.

cMyClass(); // Default constructor.

cMyClass(const cMyClass & MyClass); // Copy constructor.

cMyClass(const int i); // Overloaded constructor.

~cMyClass(); // Destructor.

private: // Member variables.

int m_int; // An integer.

int * m_pInt; // A pointer to an integer.

};

// Default constructor.

cMyClass::cMyClass(): // Colon indicates initialisation stage.

m_int( 0 ), // Comma-separated list of members to be initialised.

m_pInt( NULL ) // Optional; m_pInt will be initialised in the body.

{

// Body of the constructor:

// m_int is currently initialised to the value zero.

// m_pInt currently points to NULL.

m_pInt = new int;

*m_pInt = 0;

// m_pInt now points to new memory containing the value zero.

// Initialisation is complete!

}

// Copy constructor

cMyClass::cMyClass(const cMyClass & MyClass): // Initialisation

m_int( MyClass.m_int ), // Member list

m_pInt( NULL )

{

// m_int is initialised to the value of MyClass.m_int

// m_pInt currently points to NULL.

m_pInt = new int; // Allocate new memory.

*m_pInt = *MyClass.m_pInt; // Deep-copy the value.

// m_pInt now points to a copy of the value pointed to by MyClass.m_pInt.

// Initialisation is complete!

}

// Overloaded constructor

cMyClass::cMyClass(const int i): // Initialisation.

m_int( i ), // Member list.

m_pInt( NULL )

{

// m_int is initialised to the value of i.

// m_pInt currently points to NULL.

m_pInt = new int;

*m_pInt = 0;

// m_pInt now points to new memory containing the value zero.

// Initialisation is complete!

}

// Destructor. cMyClass::~cMyClass()

{

// Clean up allocated memory.

if( m_pInt ) delete m_pInt;

}

Classes cannot return values, only functions can return values. But you cannot return a function from a function, you can only return a function pointer -- a pointer variable holding the address of the function you wish to return. All possible return values must be of the same type, therefore all function signatures and return types must be exactly the same -- only the name of the functions can differ.

C++ has no built-in graphics methods. C++ is a machine-independent programming language, but graphics are machine-dependent. To make use of graphics of any kind, you must use a suitable graphics library. If you need cross-platform support, use a generic library.

char x,y,z;

x=100;

y=200;

z=x+y; /* overflow */

x=100;

y=100;

z=x+y; /* overflow if signed, okay if unsigned */

x=100;

y=20;

z=x+y; /* okay */

1.Bubble Sort
2.Insertion Sort
3.Shell Sort
4.Merge Sort
5.Heap Sort
6.Quick Sort
7.Bucket Sort
8.Radix Sort
9.Distribution Sort
10.Shuffle Sort

No.. It is not possible at any point

It's a c language that's developed by Denis Ritchie in 1972.

No, you don't need VC++. VC++ is often the language of choice when programming for Windows platforms (Microsoft use it in-house for all major software developements, including Windows itself), but it is not the only version of C++ capable of producing Windows programs and is by no means the cheapest. It also comes up short with regards C++ standards compliance.

The file stream classes (ifstream and ofstream) are derivatives of the I/O stream classes (istream and ostream) that are specific to file input and output.

Cardinality is the total number of unique occurances of an entity (e.g. person, organization, or transaction) that can be included in a relationship. A URI/URL, e-mail, phone number should be unique, providing a high cardinality. This means that each of the entity values would be represented at least once in a relationship. A lower cardinality value would be something like a bit, or boolean value. This value will only occur twice before becoming redundant in a relationship. So a data type value of an integer could be either low or high, depending on what the data is used for. If the values are only 0-6, then there are only 6 occurances of the data, if the field is open to the full range of data then it would be of extremely high cardinality.

Oh, dude, a mouse can totally click and drag, like, you know, move stuff around on the screen with ease. Meanwhile, a keyboard is just sitting there, like, typing away without any finesse. So, yeah, the mouse wins this round for being all hands-on and stuff.

Absolutely. Indeed, any function (user-defined or built-in) that does not return a value is not really a function, it is simply a procedure.