Emidio Planamente 's Homepage

Home GNU/Linux Programming Technology Sport Others Contact

C++ (and C)

  Boost (Smart Pointers)
  C++ Reference
  C++ Resources
  Dinkumware
  Reference Guide


Html


MySql

  Freaks
  Manual


Perl

  Perl 4
  Perl 5
  Perldoc


Php

  Freaks
  Php


Shell

  ABS
  Bash Reference


HTML validator CSS validator

 

Programming in C++

C++

Html

MySQL

Perl

Php

Shell


1. Casting

2. Class

3. Converting

4. Dependencies between .cpp and .hpp files

5. GNU/Linux related

6. Operator

7. Plain Pointer

8. Powerset

9. Smart Pointer

10. Statements

11. String

12. Template

13. Tricks

14. Vector


1. Casting


1.1. Explicit constructor


If a constructor is declared as explicit, no any hidden conversion is possible.


  explicit MyConstructor(String s);


  MyConstructor("hello");  // this is allowed

  MyConstructor("c");      // this is allowed

  MyConstructor('c');      // this is forbidden (int -> string not allowed)


2. Class


2.1. Access


The members and methods are accessible from external:


  public


The members and methods are accessible ONLY from the owner class:


  private


The members and methods are accessible from the owner class and the derived classes:


  protected


2.2. Declaring a method as const


When a method is declared as const, it can't modify the values of the class members.


  class MyClass

  {

    int a;

    int myMethod() const

    {

      return a;    // this is allowed

      return a++;  // this is forbidden

    }

  }


2.3. Declaring a variable or a parameter as const


When a variable or a parameter is declared as const, it can't be mofiefied.


  void myMethod(const int a)

  {

    cout << a;    // this is allowed

    cout << a++;  // this is forbidden

  }


2.4. Deriving a class


  Class Base

  {

    public:

      void myMethod() const = 0;

  }


  Class MyClass : public Base

  {

    public:

      void myMethod() const

      {

        return;

      }

  }


In this case, MyClass is derived from Base.


2.5. Inline


Creating a method as


  inline


doesn't create a subroutine but puts the code in each points where there is a call to such methods.


2.6. Passing parameters to a method


Generally:

A parameter should be declared as "const" only when it is a pointer or a reference.

A parameter should be declared as reference only if it size is bigger than 4 byte (call by reference).


  int


  bool


  const std::string&


  const Object&


  const Object*


2.7. Static


A class, method or member declared as static will be instanciated only once.


For all non static kind, the compiler inserts a pointer to the owner class (the "this" pointer), so that they can be identified in a unique way.

For all static kind, this pointer doesn't exist because there is only one instance.


2.8. Virtual


Generates non rewritable code:


  myMethod()


Generates rewritable code with default code:


  virtual myMethod()


Don't generate any code. This code MUST be overwritten:


  virtual MyMethod() = 0


3. Converting


3.1. Integer to ASCII


A good replacement of the itoa function is the following:


  ingeter = 10;

  char buffer[50];

  sprintf(buffer, "%d", integer);


4. Dependencies between .cpp and .hpp files


4.1. Include


When a header should be included:


  - need of base class

      e.g.: boost::noncopyable needs #include<boost/utility.hpp>

  - need of a typedef

  - need of a template

      e.g.: std::string<> needs #include<string>


When a header shouldn't be included:


  - need of a pointer, reference or smart pointer of a class or struct

  - need of a enum


In these cases, the needed type must be forward declared and the include must be done in the .cpp file.


5. GNU/Linux related


5.1. Checking for Linux version


To check for the Linux version (kernel) the following code can be used:


  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)

   mycode();

  #endif


6. Operator


6.1. Overloading


Replace the default operator with a self defined


  int operator+(int a, int b)

  {

    return a * b;

  }


  a = 3;

  b = 4;

  cout << 3 + 4


The output is:


  12


7. Plain Pointer


7.1. Instanciating a plain pointer


Plain pointer should not use constructors:


  MyStruct* myPtr = new MyStruct; // right

  MyStruct* myPtr(new MyStruct);  // wrong


Instead, smart pointers should use them:


  boost::shared_ptr<MyStruct> pTemp(new MyStruct); // right


8. Powerset


8.1. Using powerset


Consult the help for std::bitset.


9. Smart Pointer


9.1. Resetting a smart pointer


  boost:shared_ptr<MyClass> myPtr(new MyClass);

  myPtr.reset();


9.2. Setting a smart pointer


During the instance:


  boost::shared_ptr<MyClass> pSmartMyClass(new MyClass);


Later:


  boost::shared_ptr<MyClass> pSmartMyClass;

  MyClass* pMyClass = new MyClass;

  pSmartMyClass.reset(pMyClass);


9.3. Returning a smart pointer


  bool myFunction(boost::shared_ptr<MyObject> pMyObject)

  {

    MyObject* pTemp(new MyObject);

    pMyObject.reset(pTemp);

  }


  boost::shared_ptr<MyObject> pMyObject(new MyObject);

  myFunction(pMyObject);


9.4. Returning more smart pointers


Possibility 1 (esiest):


  void method1(

    boost::shared_ptr<Class1>& p1,

    boost::shared_ptr<Class2>& p2

    )

  {

    ...

    p1.reset(new MyClass1); // works sure

    // p1 = boost::shared_ptr<Sub1>(new MyClass1); // should work

    p2.reset(new MyClass2);

    ...

  }


  boost::shared_ptr<Class1> p1((Class1*)0);

  boost::shared_ptr<Class2> p2((Class2*)0);

  method1(v1, v2);



Possibility 2:


  std::pair<boost::shared_ptr<Class1>, boost::shared_ptr<Class2> > method2()

  {

    ...

    return std::pair<boost::shared_ptr<Class1>, boost::shared_ptr<Class2> >(new Sub1, new Sub2);

  }


9.5. Using smart pointers with plain pointers


Plain pointer to smart pointer:


  MyClass* pMyClass = new MyClass;

  boost::shared_ptr<MyClass> pSmartMyClass;

  pSmartMyClass.reset(pMyClass);


or simply


  pSmartMyClass.reset(new MyClass);


Smart pointer to plain pointer:


  boost::shared_ptr<MyClass> pSmartMyClass(new MyClass);

  MyClass* pMyClass = 0;

  pMyClass = pSmartMyClass.get();


Never use get() and reset() methods when both are smart pointers.


  boost::shared_ptr<MyClass> pSmartMyClass1;

  boost::shared_ptr<MyClass> pSmartMyClass2;


  pSmartMyClass1 = pSmartMyClass2;             // right

  pSmartMyClass1.reset(pSmartMyClass2);        // wrong

  pSmartMyClass1.reset(pSmartMyClass2.get());  // wrong

  pSmartMyClass1 = pSmartMyClass2.get();       // wrong


10. Statements


10.1. If ... then ... else


Alternatively to the classical syntax, it's possible to use the following instead:


  (condition) ? (cout << "true") : ("cout << "false")


This is normally used for short commands and is normally placed on a single line.


10.2. Switch statement


  switch(myVariable)

  {

    case 1:

    {

      return true;

    }

    break;


    case 2:

    {

      return true;

    }

    break;


    default:

    {

      return false;

    }

    break;

  }


11. String


11.1. Copying array of char to std::string


  char myArray[] "Hello";

  unsigned int myArrayLenght = 4;

  std::string myString;


  myString.assign(myArray, myArray + myArrayLenght);


11.2. Declaring a string and initializing it with more char[]


  #define "One";

  #define "Two";

  std::string myString = "One" "Two";


12. Template


12.1. Usage


A template provides the capability to define classes and methods without specifying the type of input/output.


Here an example:


This should be placed in the .cpp file:


  template <typename MyType>

    MyMethod(MyType myParameter)

    {

      // make something with myParameter

    }


This should be placed in the .hpp file:


  template<typename MyType>

    clss Class

    {

      public:

        void myMethod(MyType);

    }


And here is an example about how to use it:


  Class<in> intClass;

  Class<string> stringClass;

  intClass.myMethod(5);

  stringClass.MyMethod("hello");


13. Tricks


13.1. Copying a structure


If the structure doesn't contain pointers or references, it's possible to copy  it with the operator =.


  typedef struct MyStruct

  {

    int foo;

    char bar;

  }

  MyStruct;



  MyStruct a, b;


  a.foo = 1;

  a.bar = 2;


  b = a;


In this case, the operator= is called for each member and struct a is copied one byte after the other to struct b.



Note:


  MyStruct* pA, pB;


  pA = pB;


In this case, only the pointers copied!



Danger: if the structure contains pointers or references, only the pointers will be copied and not the content where they point to.


Therefore, in this case, one solution is to use memcpy:


  typedef struct MyStruct

  {

    int length;

    char* value;

  }

  MyStruct;


  MyStruct a, b;

  char string[] = "Emi";


  a.length = strlen(string);

  a.value = new char[strlen(string)];

  a.value = string;


  b.length = a.length;

  b.value = new char[b.length];

  memcpy(b.value, a.value, a.length);



On other solution is to use std::copy:


  std::copy(a.value, a.value + a.length, b.value);


Note: std::string needs the following line


  #include<string>


13.2. Initializing a structure


This will initialize the structure with zeros:


  memset(&myStruct, 0, sizeof(myStruct);


13.3. Setting, resetting and checking bit


Given:

  FLAG = 0x0100

  int bitmask = 0;


Set bit:

  bitmask |= FLAG;


Reset bit:

  bitmask &= ~FLAG;


Check bit:

  if((bitmask & FLAG) == FLAG)

  {

    print "Bit is set\n";

  }

  else

  {

    print "Bit is not set\n";

  }


14. Vector


14.1. Printing a vector


  for(size_t i = 0; i < vector.size(); i++)

  {

    std::cout << vector[i] << std::endl;

  }


14.2. Copying a vector


  MyClass objectA, objectB;


  std::vector<MyClass> v1, v2;


  v1.push_back(objectA);

  v1.push_back(objectB);

  v1.insert(v1, v1.end(), v2.begin(), b2.end());


14.3. Shifting a vector


To shift left:


  std::vector<char>::iterator b = input.begin();

  std::advance(b, shiftNbytes);

  input.erase(input.begin(), b);




C++

Html

MySQL

Perl

Php

Shell


Emidio Planamente

Last modified on 2024-08-02