0
I guess its 15 yrs. I was allowed to write my boards in 2007 (my birth year being 1992) so i guess you have 2 be at least 14 and a half or fifteen years old!
The student should have completed the age of 14 on the first day of the month in which the examination is to be conducted . However, exemption can be availed as below:
The following authorities are competent to grant age exemption noted below:
Up to two years : D.E.O. Concerned.
More than two years : C.E.O. Concerned.
Such candidate should apply for the exemption accompanied by a Medical Certificate signed by a Medical Practitioner. The Head of the schools should recommend their applications.
These rules are framed by the State Govt. of Tamilnadu. This may differ from other State Govt./Union territory rules.
Here is the link: http://dge.tn.gov.in/exams/SSLC.HTM#4b
These rules apply to CBSE Std X also as they follow the State Govt. rules where the school is located. Visit the following link:http://cbse.nic.in/examin~1/admissionmt.htm
For ICSE std X:here is no age limit for candidates taking the examination.
Visit this link: http://www.cisce.org/ICSE%20SYLLABUSES%202012%20FINAL%20CRC/1.Syllabus%20Regulations.pdf
Wiki User
∙ 10y ago
Add your answer:
Earn +20 pts
Could you find Palayamkottai Xstd half yearly Question papers matriculation?
lavada
What are all of the mathematical symbols?
=equals signequality5 = 2+3≠not equal signinequality5 ≠ 4>strict inequalitygreater than5 > 4
How to overloade operater in c plus plus?
The assignment operator overload is a typical example of operator overloading. Every class of object has an assignment operator by default, which simply assigns the value of the members of an existing class to the members of another existing class. The two classes may even be the same class. However, the default implementation is not suitable for classes that contain pointers to memory that cannot be shared with other classes. Assigning the value of one pointer to another simply copies the pointer's value (a shallow copy) but not what it points at (a deep copy). Thus the assignment operator must be overloaded to perform a deep-copy, as per the following example: struct X { // destructor ~X(){ delete( m_pointer ); } // default constructor X(): m_pointer( new int(100) ){} // copy constructor X( const X& x): m_pointer( x.m_pointer ? new int( *x.m_pointer) : NULL ) {} // assignment operator overload X& operator= ( const X& x ); int* m_pointer; }; X& X::operator= ( const X& x ) { if( this != &x ) // test for self-reference {delete( m_pointer );m_pointer = x.m_pointer ? new int(*x.m_pointer) : NULL;} return( *this ); } In the above example, the assignment operator overload first checks to ensure that the incoming object is not a self-reference. If it is not, then we release the current allocation and create a new allocation, copying the incoming object's memory by value. If we had not checked for a self-reference, then we could easily end up deleting the very memory we wished to copy, such as in the following example: X x; X* y = &x; x = *y; // self-assignment In the above example, x and *y are obviously references to the same object, but it may not be quite so obvious if the assignment occurred elsewhere in our code. Therefore the object's assignment operator overload must cater for this eventuality and veto the assignment -- thus leaving the original object unchanged. The assignment operator can also be overloaded in order to prevent assignment. You would do this if the object were intended to act as a singleton, for instance. In this case we simply need to declare the operator as private to the class but do not need to provide any implementation. Alternatively, we can simply return a reference to the current instance: X& operator= ( const X& x ) { return( *this ); } No other operator has a default implementation when applied to classes, therefore if we want to make use of other operators upon our classes, such as +, ++ or +=, then we must overload them in the class declaration. Again, each overload must test for self-references and act accordingly. However, while there's nothing to prevent you from providing a completely unique implementation of these operators, common sense dictates that all such implementations must be intuitive and predictable. While it may be fun to implement the plus operator as a minus operation, it has no practical value in the real world -- it is neither intuitive nor predictable. The stream insertion (<<) and extraction (>>) operators are another typical example of operator overloading. These cannot be implemented within the class itself because the l-value of these operators must be a stream, while internal class operator overloads use the current instance of the class as the l-value. Therefore these operators must be implemented outside of the class. Many programmers implement these "external" operators as friend functions. While some do have valid reasons for doing so, if the public class interface provides everything required of these operators then there is no need to declare the operator as a friend function. Although some programmers continually claim friendship undermines encapsulation this is not the case at all. Friends simply extend the class interface, nothing more. However, if the underlying class implementation is altered, all friend functions may need to be updated to cater for these changes -- which increases the maintenance cost. Therefore, if operator overloads can be implemented with friend access, then your class becomes that much easier to maintain. Here's a typical example of an external operator implemented as a friend function: struc X { friend ostream& operator<<( const X& x ); private: int m_data; }; ostream& operator<<( ostream& os, const X& x ) { os << x.m_data; return( os ); } Now here's the same operator overload implemented without a friend function: struc X { int GetData() const { return( m_data ); } private: int m_data; }; ostream& operator<<( ostream& os, const X& x ) { os << x.GetData(); return( os ); } While there's clearly the need for an extra function call, that call is completely eliminated by virtue of the fact X::GetData() will be inline expanded by the compiler. Thus the latter will not affect performance in any way. However, the main advantage of the non-friend function comes when you later decide to alter the implementation of the class: struc X { int GetData() const { return(( int ) m_data ); } private: double m_data; }; Here we've changed the member variable to a double, but the GetData() accessor method still returns an int. The accessor is therefore an abstraction, thus the insertion operator overload is left unaffected by the internal change to the class. However, had we made this same change in the earlier example employing the friend function, there is no abstraction and the extraction operator will insert a double into the output stream. If this were undesirable then we'd have to alter the friend function as well. Not only have we increased the maintenance, we've completely undermined the abstraction of our class. Note that we have not undermined the encapsulation (as some would claim), only the abstraction has been undermined. Thus if you want to retain the abstraction, do not use a friend function. Friend functions should only be used when abstraction is not an issue, and the function genuinely requires access to the private members of the class.
