Fix character string literal usage.

-- Paul Russo


git-svn-id: http://root.cern.ch/svn/root/trunk@24877 27541ba8-7e3a-0410-8455-c3a389f83636

cint/test/VArray.cxx

@@ -5,184 +5,156 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/**********************************************************
-* 
-**********************************************************/
 
 #include "VArray.h"
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
+#include <algorithm>
+#include <cassert>
+
+using namespace std;
+
 VArray::VArray()
+: numElements(0)
+, adrAry(0)
 {
-  numElements = 0;
-  adrAry = (VObject**)NULL;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-VArray::VArray(VArray& obj)
+VArray::VArray(const VArray& obj)
+: numElements(0)
+, adrAry(0)
 {
-  Int_t result;
-
-  numElements = 0;
-  adrAry = (VObject**)NULL;
-
-  result = SetNumElements(obj.GetNumElements());
-  if(SUCCESS!=result) return;
-
-  for(Int_t i=0;i<numElements;i++) adrAry[i] = obj.adrAry[i];
+   int result = SetNumElements(obj.GetNumElements());
+   if (result != SUCCESS) {
+      return;
+   }
+   for (int i = 0; i < numElements; ++i) {
+      adrAry[i] = obj.adrAry[i];
+   }
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-VArray& VArray::operator=(VArray& obj)
+VArray& VArray::operator=(const VArray& obj)
 {
-  Int_t result;
-
-  result = SetNumElements(obj.GetNumElements());
-  if(SUCCESS!=result) return(*this);
-
-  for(Int_t i=0;i<numElements;i++) adrAry[i] = obj.adrAry[i];
-
-  return(*this);
+   if (this != &obj) {
+      int result = SetNumElements(obj.GetNumElements());
+      if (result != SUCCESS) {
+         return *this;
+      }
+      for (int i = 0; i < numElements; ++i) {
+         adrAry[i] = obj.adrAry[i];
+      }
+   }
+   return *this;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
 VArray::~VArray()
 {
-  if(adrAry) {
-    delete[] adrAry;
-    adrAry = (VObject**)NULL;
-  }
+   delete[] adrAry;
+   adrAry = 0;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-Int_t VArray::SetNumElements(Int_t numin)
+int VArray::SetNumElements(int numin)
 {
-  VObject** storeAry = adrAry;
-  Int_t storeNum = numElements;
-  
-  if(numin<0) return FAILURE;
-  else if(0==numin) {
-    if(adrAry) {
+   VObject** storeAry = adrAry;
+   int storeNum = numElements;
+   if (numin < 0) {
+      return FAILURE;
+   }
+   else if (!numin) {
       delete[] adrAry;
-      adrAry = (VObject**)NULL;
-    }
-    numElements = numin;
-    return(SUCCESS);
-  }
-
-
-  numElements = numin;
-  adrAry = new VObject*[numElements];
-  if((VObject**)NULL==adrAry) {
-    adrAry = storeAry;
-    numElements = storeNum;
-    return(FAILURE);
-  }
-
-  if(storeAry) {
-    Int_t minNum = MIN(numElements,storeNum);
-    Int_t i;
-    for(i=0;i<minNum;i++) adrAry[i] = storeAry[i];
-    delete[] storeAry;
-  }
-
-  return(SUCCESS);
+      adrAry = 0;
+      numElements = numin;
+      return SUCCESS;
+   }
+   numElements = numin;
+   adrAry = new VObject*[numElements];
+   if (!adrAry) {
+      adrAry = storeAry;
+      numElements = storeNum;
+      return FAILURE;
+   }
+   if (storeAry) {
+      int minNum = min(numElements, storeNum);
+      for (int i = 0; i < minNum; ++i) {
+         adrAry[i] = storeAry[i];
+      }
+      delete[] storeAry;
+   }
+   return SUCCESS;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-Int_t VArray::Add(VObject* obj,Int_t index)
+int VArray::Add(VObject* obj, int index)
 {
-  ///* DEBUG */ printf("Add(%p)\n",obj);
-  VObject** storeAry = adrAry;
-  void *ppp = adrAry;
-
-  adrAry = new VObject*[++numElements];
-  if((VObject**)NULL==adrAry) {
-    adrAry = storeAry;
-    --numElements;
-    return(FAILURE);
-  }
-
-  if(index<0||numElements-1<index) index = numElements-1;
-
-  if(storeAry) {
-    Int_t i;
-    for(i=0;i<index;i++) adrAry[i] = storeAry[i];
-    ///*DEBUG*/ for(i=0;i<index;i++) printf("%d:%lx:%lx ",i,adrAry[i],storeAry[i]);
-    ///*DEBUG*/printf("\n");
-    adrAry[index] = obj;
-    for(i=index+1;i<numElements;i++) adrAry[i] = storeAry[i-1];
-    delete[] storeAry;
-  }
-  else {
-    assert(0==index);
-    adrAry[index] = obj;
-  }
-
-  ///* DEBUG */ printf("%lx.%d Add(%lx) = %lx\n",this,index,adrAry[index],obj);
-  //G__pause();
-  return(SUCCESS);
+   VObject** storeAry = adrAry;
+   void *ppp = adrAry;
+   adrAry = new VObject*[++numElements];
+   if (!adrAry) {
+      adrAry = storeAry;
+      --numElements;
+      return FAILURE;
+   }
+   if ((index < 0) || ((numElements - 1) < index)) {
+      index = numElements - 1;
+   }
+   if (storeAry) {
+      for (int i = 0; i < index; ++i) {
+         adrAry[i] = storeAry[i];
+      }
+      adrAry[index] = obj;
+      for (int i = index + 1; i < numElements; ++i) {
+         adrAry[i] = storeAry[i-1];
+      }
+      delete[] storeAry;
+   }
+   else {
+      assert(index == 0);
+      adrAry[index] = obj;
+   }
+   return SUCCESS;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-VObject* VArray::Delete(Int_t index,Int_t flag)
+VObject* VArray::Delete(int index, int flag)
 {
-  if(index<0||numElements-1<index) index=numElements-1;
-
-  VObject** storeAry = adrAry;
-  assert((VObject**)NULL!=adrAry);
-
-  VObject *p = storeAry[index];
-
-  if(flag) {
-    delete p;
-    p = (VObject*)NULL;
-  }
-
-  if(1==numElements) {
-    numElements = 0;
-    delete[] adrAry;
-    adrAry = (VObject**)NULL;
-    return(p);
-  }
-
-  assert(2<=numElements);
-
-  adrAry = new VObject*[--numElements];
-  if((VObject**)NULL==adrAry) {
-    adrAry = storeAry;
-    ++numElements;
-    return(NULL);
-  }
-
-  if(storeAry) {
-    Int_t i;
-    for(i=0;i<index;i++) adrAry[i] = storeAry[i];
-    for(i=index+1;i<numElements+1;i++) adrAry[i-1] = storeAry[i];
-    delete[] storeAry;
-  }
-
-  return(p);
+   if ((index < 0) || ((numElements - 1) < index)) {
+      index = numElements - 1;
+   }
+   VObject** storeAry = adrAry;
+   assert(adrAry != 0);
+   VObject* p = storeAry[index];
+   if (flag) {
+      delete p;
+      p = 0;
+   }
+   if (numElements == 1) {
+      numElements = 0;
+      delete[] adrAry;
+      adrAry = 0;
+      return p;
+   }
+   assert(numElements >= 2);
+   adrAry = new VObject*[--numElements];
+   if (!adrAry) {
+      adrAry = storeAry;
+      ++numElements;
+      return 0;
+   }
+   if (storeAry) {
+      for (int i = 0; i < index; ++i) {
+         adrAry[i] = storeAry[i];
+      }
+      for (int i = index + 1; i < (numElements + 1); ++i) {
+         adrAry[i-1] = storeAry[i];
+      }
+      delete[] storeAry;
+   }
+   return p;
 }
 
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-VObject* VArray::GetElement(Int_t index)
+VObject* VArray::GetElement(int index)
 {
-  if(index<0 || numElements<=index) {
-    assert(0);
-    return(adrAry[0]);
-  }
-
-  ///* DEBUG */ printf("%lx.%d GetElement(%lx)\n",this,index,adrAry[index]);
-  //G__pause();
-  return(adrAry[index]);
+   if ((index < 0) || (numElements <= index)) {
+      assert(0);
+      return adrAry[0];
+   }
+   return adrAry[index];
 }
 

cint/test/VArray.h

@@ -5,47 +5,44 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VArray.h , C++
-*
-************************************************************************
-* Description:
-*
-***********************************************************************/
 
 #ifndef VARRAY_H
 #define VARRAY_H
 
-#include "VType.h"
 #include "VObject.h"
+#include "VType.h"
 
 #define INVALIDINDEX -1
 
-/**********************************************************
-* Polymorphic Array object
-**********************************************************/
+class VArray : public VObject
+{
+   // Polymorphic Array object
+public:
 
-class VArray : public VObject {
- public:
+   VArray();
+   VArray(const VArray& obj);
+   VArray& operator=(const VArray& obj);
+   ~VArray();
 
-  VArray();
-  VArray(VArray& obj);
-  VArray& operator=(VArray& obj); 
-  ~VArray();
-  // Int_t operator==(VArray& x);
+   int SetNumElements(int numin);
+   int Add(VObject* obj, int index = INVALIDINDEX);
+   VObject* Delete(int index = INVALIDINDEX, int flag = 0);
 
-  Int_t SetNumElements(Int_t numin);
-  Int_t Add(VObject* obj,Int_t index=INVALIDINDEX);
-  VObject* Delete(Int_t index=INVALIDINDEX,Int_t flag=0);
+   int GetNumElements() const
+   {
+      return numElements;
+   }
 
-  Int_t GetNumElements() { return numElements;}
-  VObject* GetElement(Int_t index);
-  VObject& operator[](Int_t index) { return(*GetElement(index)); }
+   VObject* GetElement(int index);
 
- private:
-  Int_t numElements;  
-  VObject**    adrAry;
-};
+   VObject& operator[](int index)
+   {
+      return *GetElement(index);
+   }
 
-#endif
+private:
+   int numElements;
+   VObject** adrAry;
+};
 
+#endif // VARRAY_H

cint/test/VCompany.cxx

@@ -6,51 +6,61 @@
  *
  ************************************************************************/
 
+#include "VCompany.h"
 
-#ifdef __hpux
-#include <iostream.h>
-#else
 #include <iostream>
+
 using namespace std;
-#endif
-#include "VCompany.h"
 
-VCompany::VCompany() : VObject() , name() , country()
+VCompany::VCompany()
+      : VObject()
 {
 }
 
-VCompany::VCompany(VCompany& x) : VObject() , name(x.name) , country(x.country)
+VCompany::VCompany(const VCompany& x)
+: VObject()
+, name(x.name)
+, country(x.country)
 {
 }
 
-VCompany::VCompany(Char_t* nameIn,Char_t* countryIn) : VObject() , name(nameIn) , country(countryIn)
+VCompany::VCompany(const char* nameIn, const char* countryIn)
+: VObject()
+, name(nameIn)
+, country(countryIn)
 {
 }
 
-VCompany::VCompany(Char_t* nameIn,Int_t num) : VObject(), name(nameIn), country()
+VCompany::VCompany(const char* nameIn, int num)
+: VObject()
+, name(nameIn)
 {
-  char buf[10];
-  sprintf(buf,"country%d",num);
-  country = buf;
+   char buf[256];
+   sprintf(buf, "country%d", num);
+   country = buf;
 }
 
-VCompany& VCompany::operator=(VCompany& x) 
+VCompany& VCompany::operator=(const VCompany& x)
 {
-  name = x.name;
-  country = x.country;
-  return x;
+   if (this != &x) {
+      name = x.name;
+      country = x.country;
+   }
+   return *this;
 }
 
-VCompany::~VCompany() 
+VCompany::~VCompany()
 {
 }
 
-void VCompany::set(Char_t* nameIn,Char_t* countryIn)
+void VCompany::set(const char* nameIn, const char* countryIn)
 {
-  name = nameIn;
-  country = countryIn;
+   name = nameIn;
+   country = countryIn;
 }
 
-void VCompany::disp() {
-  cout << name.String() << " " << country.String() << endl;  
+void VCompany::disp()
+{
+   cout << name.String() << " " << country.String() << endl;
 }
+

cint/test/VCompany.h

@@ -6,24 +6,38 @@
  *
  ************************************************************************/
 
-//#pragma includepath "\mpn\ke\proto3"
-#include "VString.h"
+#ifndef VCOMPANY_H
+#define VCOMPANY_H
+
 #include "VObject.h"
+#include "VString.h"
+
+class VCompany : public VObject
+{
+public:
+   VCompany();
+   VCompany(const VCompany& x);
+   VCompany(const char* nameIn, const char* countryIn);
+   VCompany(const char* nameIn, int num);
+   VCompany& operator=(const VCompany& x);
+   ~VCompany();
+   void set(const char* nameIn, const char* countryIn);
+
+   const char* Name()
+   {
+      return name.String();
+   }
+
+   const char* Syozoku()
+   {
+      return country.String();
+   }
+
+   void disp();
 
-class VCompany : public VObject {
- public:
-  VCompany();
-  VCompany(VCompany& x);
-  VCompany(Char_t* nameIn,Char_t* countryIn);
-  VCompany(Char_t* nameIn,Int_t num);
-  VCompany& operator=(VCompany& x);
-  ~VCompany();
-  void set(Char_t* nameIn,Char_t* countryIn);
-  Char_t* Name() { return(name.String()); }
-  Char_t* Syozoku() { return(country.String()); }
-  void disp();
- private:
-  VString name;
-  VString country;
+private:
+   VString name;
+   VString country;
 };
 
+#endif // VCOMPANY_H

cint/test/VObject.cxx

@@ -5,52 +5,28 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VObject.cxx , C++
-*
-************************************************************************
-* Description:
-*
-***********************************************************************/
-
-#ifdef __hpux
-#include <iostream.h>
-#else
+
+#include "VObject.h"
+
 #include <iostream>
+
 using namespace std;
-#endif
-#include "VObject.h"
 
-///////////////////////////////////////////////////////////
-// 
-///////////////////////////////////////////////////////////
 VObject::VObject()
 {
 }
 
-///////////////////////////////////////////////////////////
-// 
-///////////////////////////////////////////////////////////
-VObject::VObject(VObject& x)
+VObject::VObject(const VObject& x)
 {
 }
 
-///////////////////////////////////////////////////////////
-// 
-///////////////////////////////////////////////////////////
-VObject& VObject::operator=(VObject& x)
+VObject& VObject::operator=(const VObject& x)
 {
-  cerr << "VObject::operator=() must be overridden" << endl;  
-  return x;
+   cerr << "VObject::operator=() must be overridden" << endl;
+   return *this;
 }
 
-///////////////////////////////////////////////////////////
-// 
-///////////////////////////////////////////////////////////
 VObject::~VObject()
 {
-  //cerr << "VObject::~VObject() must be overridden" << endl;  
 }
 
-
-

cint/test/VObject.h

@@ -5,29 +5,24 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VObject.h , C++
-*
-************************************************************************
-* Description:
-*
-***********************************************************************/
-
 #ifndef VOBJECT_H
 #define VOBJECT_H
 
 #include "VType.h"
 
-class VObject {
- public:
-  VObject();
-  VObject(VObject& x);
-  virtual VObject& operator=(VObject& x);
-  virtual ~VObject();
-  virtual void disp() { 
-    cout << "(VObject)" << endl;  
-  }
-};
+#include <iostream>
 
-#endif
+class VObject
+{
+public:
+   VObject();
+   VObject(const VObject& x);
+   virtual VObject& operator=(const VObject& x);
+   virtual ~VObject();
+   virtual void disp()
+   {
+      std::cout << "(VObject)" << std::endl;
+   }
+};
 
+#endif // VOBJECT_H

cint/test/VPerson.cxx

@@ -6,51 +6,63 @@
  *
  ************************************************************************/
 
+#include "VPerson.h"
 
-#ifdef __hpux
-#include <iostream.h>
-#else
 #include <iostream>
+
 using namespace std;
-#endif
-#include "VPerson.h"
 
-VPerson::VPerson() : VObject() , name() , syozoku()
+VPerson::VPerson()
+: VObject()
+, name()
+, syozoku()
 {
 }
 
-VPerson::VPerson(VPerson& x) : VObject() , name(x.name) , syozoku(x.syozoku)
+VPerson::VPerson(const VPerson& x)
+: VObject(x)
+, name(x.name)
+, syozoku(x.syozoku)
 {
 }
 
-VPerson::VPerson(Char_t* nameIn,Char_t* syozokuIn) : VObject() , name(nameIn) , syozoku(syozokuIn)
+VPerson::VPerson(const char* nameIn, const char* syozokuIn)
+: VObject()
+, name(nameIn)
+, syozoku(syozokuIn)
 {
 }
 
-VPerson::VPerson(Char_t* nameIn,Int_t num) : VObject(), name(nameIn), syozoku()
+VPerson::VPerson(const char* nameIn, int num)
+: VObject()
+, name(nameIn)
 {
-  char buf[10];
-  sprintf(buf,"syozoku%d",num);
-  syozoku = buf;
+   char buf[256];
+   sprintf(buf, "syozoku%d", num);
+   syozoku = buf;
 }
 
-VPerson& VPerson::operator=(VPerson& x) 
+VPerson& VPerson::operator=(const VPerson& x)
 {
-  name = x.name;
-  syozoku = x.syozoku;
-  return x;
+   if (this != &x) {
+      name = x.name;
+      syozoku = x.syozoku;
+   }
+   return *this;
 }
 
-VPerson::~VPerson() 
+VPerson::~VPerson()
 {
 }
 
-void VPerson::set(Char_t* nameIn,Char_t* syozokuIn)
+void VPerson::set(const char* nameIn, const char* syozokuIn)
 {
-  name = nameIn;
-  syozoku = syozokuIn;
+   name = nameIn;
+   syozoku = syozokuIn;
 }
 
-void VPerson::disp() {
-  cout << name.String() << " " << syozoku.String() << endl;  
+void VPerson::disp()
+{
+   cout << name.String() << " " << syozoku.String() << endl;
 }
+

cint/test/VPerson.h

@@ -6,24 +6,38 @@
  *
  ************************************************************************/
 
-//#pragma includepath "\mpn\ke\proto3"
+#ifndef VPERSON_H
+#define VPERSON_H
+
 #include "VString.h"
 #include "VObject.h"
 
-class VPerson : public VObject {
- public:
-  VPerson();
-  VPerson(VPerson& x);
-  VPerson(Char_t* nameIn,Char_t* syozokuIn);
-  VPerson(Char_t* nameIn,Int_t num);
-  VPerson& operator=(VPerson& x);
-  ~VPerson();
-  void set(Char_t* nameIn,Char_t* shozokuIn);
-  Char_t* Name() { return(name.String()); }
-  Char_t* Syozoku() { return(syozoku.String()); }
-  void disp();
- private:
-  VString name;
-  VString syozoku;
+class VPerson : public VObject
+{
+public:
+   VPerson();
+   VPerson(const VPerson& x);
+   VPerson(const char* nameIn, const char* syozokuIn);
+   VPerson(const char* nameIn, int num);
+   VPerson& operator=(const VPerson& x);
+   ~VPerson();
+   void set(const char* nameIn, const char* shozokuIn);
+
+   const char* Name()
+   {
+      return name.String();
+   }
+
+   const char* Syozoku()
+   {
+      return syozoku.String();
+   }
+
+   void disp();
+
+private:
+   VString name;
+   VString syozoku;
 };
 
+#endif // VPERSON_H

cint/test/VPersonTest.cxx

@@ -5,92 +5,67 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
+
 #define INTERP
+
 #ifdef INTERP
 #include "VObject.cxx"
 #include "VPerson.cxx"
 #include "VCompany.cxx"
 #include "VArray.cxx"
 #include "VString.cxx"
-#else
+#else // INTERP
 #include "VPerson.dll"
-#endif
+#endif // INTERP
 
 #define NUM 5
 
-#if 0
-void test0() {
-  VArray a;
-  VPerson* p;
-  VCompany* p1;
-  Int_t i;
-  p=new VPerson("name0",i);
-  a.Add(p,-1);
-  p1=new VCompany("company1",i);
-  a.Add(p1,-1);
-  p=new VPerson("name2",i);
-  a.Add(p,-1);
-  p1=new VCompany("company3",i);
-  a.Add(p1,-1);
-  p=new VPerson("name4",i);
-  a.Add(p,-1);
-
-  for(i=0;i<NUM;i++) {
-    a[i].disp();
-  }  
-
-  for(i=0;i<NUM;i++) {
-    delete a.Delete(-1,0);
-  }  
+void test1()
+{
+   VArray a;
+   VPerson* p = 0;
+   VCompany* p1 = 0;
+   for (int i = 0; i < NUM; ++i) {
+      if (i % 2) {
+         p = new VPerson("name", i);
+         a.Add(p, -1);
+      }
+      else {
+         p1 = new VCompany("company", i);
+         a.Add(p1, -1);
+      }
+   }
+   for (int i = 0; i < NUM; ++i) {
+      a[i].disp();
+   }
+   for (int i = 0; i < NUM; ++i) {
+      delete a.Delete(-1, 0);
+   }
 }
-#endif
-
-void test1() {
-  VArray a;
-  VPerson* p;
-  VCompany* p1;
-  Int_t i;
-  for(i=0;i<NUM;i++) {
-    if(i%2) {
-      p=new VPerson("name",i);
-      a.Add(p,-1);
-    }
-    else {
-      p1=new VCompany("company",i);
-      a.Add(p1,-1);
-    }
-  }  
 
-  for(i=0;i<NUM;i++) {
-    a[i].disp();
-  }  
-
-  for(i=0;i<NUM;i++) {
-    delete a.Delete(-1,0);
-  }  
+void test2()
+{
+   VArray a;
+   for (int i = 0; i < NUM; ++i) {
+      if (i % 2) {
+         a.Add(new VPerson("name", i), -1);
+      }
+      else {
+         a.Add(new VCompany("company", i), -1);
+      }
+   }
+   for (int i = 0; i < NUM; ++i) {
+      a[i].disp();
+   }
+   for (int i = 0; i < NUM; ++i) {
+      a.Delete(-1, 1);
+   }
 }
 
-void test2() {
-  VArray a;
-  //VPerson* p;
-  Int_t i;
-  for(i=0;i<NUM;i++) {
-    if(i%2) a.Add(new VPerson("name",i),-1);
-    else    a.Add(new VCompany("company",i),-1);
-  }  
-
-  for(i=0;i<NUM;i++) {
-    a[i].disp();
-  }  
-
-  for(i=0;i<NUM;i++) {
-    a.Delete(-1,1);
-  }  
+int main()
+{
+   test1();
+   test2();
+   return 0;
 }
 
-int main() {
-  //test0();
-  test1();
-  test2();
-  return 0;
-}

cint/test/VString.cxx

@@ -5,176 +5,129 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VString.cxx , C++
-*
-************************************************************************
-* Description:
-***********************************************************************/
 
 #include "VString.h"
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-VString::VString(const Char_t* strIn )
-{
-  str = (Char_t*)NULL;
-  len = 0;
+using namespace std;
 
-  if(strIn && strIn[0]) {
-    len = strlen(strIn);
-    str = new Char_t[len+1];
-    strcpy(str,strIn);
-  }
+VString::VString(const char* strIn)
+: len(0)
+, str(0)
+{
+   if (strIn && strIn[0]) {
+      len = strlen(strIn);
+      str = new char[len+1];
+      strcpy(str, strIn);
+   }
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-VString::VString(const VString& kstrIn )
+VString::VString(const VString& kstrIn)
+: len(0)
+, str(0)
 {
-  str = (Char_t*)NULL;
-  len = 0;
-
-  if(kstrIn.str) {
-    len = kstrIn.len;
-    str = new Char_t[len+1];
-    strcpy(str,kstrIn.str);
-  }
+   if (kstrIn.str) {
+      len = kstrIn.len;
+      str = new char[len+1];
+      strcpy(str, kstrIn.str);
+   }
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
 VString& VString::operator=(const VString& obj)
 {
-  if(str) delete[] str;
-  str = (Char_t*)NULL;
-  len = 0;
-
-  if(obj.str) {
-    len = obj.len;
-    str = new Char_t[len+1];
-    strcpy(str,obj.str);
-  }
-
-  return(*this);
+   if (this != &obj) {
+      len = 0;
+      delete[] str;
+      str = 0;
+      if (obj.str) {
+         len = obj.len;
+         str = new char[len+1];
+         strcpy(str, obj.str);
+      }
+   }
+   return *this;
 }
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-VString& VString::operator=(const Char_t* s)
-{
-  if(str) delete[] str;
-  str = (Char_t*)NULL;
-  len = 0;
-
-  if(s && s[0]) {
-    len = strlen(s);
-    str = new Char_t[len+1];
-    strcpy(str,s);
-  }
 
-  return(*this);
+VString& VString::operator=(const char* s)
+{
+   len = 0;
+   delete[] str;
+   str = 0;
+   if (s && s[0]) {
+      len = strlen(s);
+      str = new char[len+1];
+      strcpy(str, s);
+   }
+   return *this;
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
 void VString::append(const VString& s)
 {
-  if(0==s.len) return;
-  append(s.str);
+   if (!s.len) {
+      return;
+   }
+   append(s.str);
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-void VString::append(const Char_t* s)
+void VString::append(const char* s)
 {
-  if(!s) return;
-  if(str) {
-    len = len + strlen(s);
-    Char_t* p = new Char_t[len+1];
-    sprintf(p,"%s%s",str,s);
-    delete[] str;
-    str = p;
-  }
-  else {
-    *this = s;
-  }
+   if (!s) {
+      return;
+   }
+   if (str) {
+      len = len + strlen(s);
+      char* p = new char[len+1];
+      sprintf(p, "%s%s", str, s);
+      delete[] str;
+      str = p;
+   }
+   else {
+      *this = s;
+   }
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-Int_t VString::Write(FILE* fp)
+int VString::Write(FILE* fp)
 {
-  fwrite((void*)(&len) ,sizeof(len) ,1,fp);
-
-  if(len) fwrite((void*)(str) ,(size_t)(len+1) ,1,fp);
-
-  return(SUCCESS);
+   fwrite(&len, sizeof(len), 1, fp);
+   if (len) {
+      fwrite(str, len + 1, 1, fp);
+   }
+   return SUCCESS;
 }
 
-
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-Int_t VString::Read(FILE* fp)
+int VString::Read(FILE* fp)
 {
-  if(str) delete[] str;
-  str = (Char_t*)NULL;
-  len = 0;
-
-  fread((void*)(&len) ,sizeof(len) ,1,fp);
-
-  if(len) {
-    str = new Char_t[len+1];
-    fread((void*)(str) ,(size_t)(len+1) ,1,fp);
-  }
-
-  return(SUCCESS);
+   len = 0;
+   delete[] str;
+   str = 0;
+   fread(&len, sizeof(len), 1, fp);
+   if (len) {
+      str = new char[len+1];
+      fread(str, len + 1, 1, fp);
+   }
+   return SUCCESS;
 }
 
-Int_t Debug=0;
+int Debug = 0;
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-int strcmp(const VString& a,const Char_t* b)
+int strcmp(const VString& a, const char* b)
 {
-  if(a.len==0 && strlen(b)==0) {
-    return 0;
-  }
-  else if(a.len>0 && strlen(b)>0) {
-    return(strcmp(a.str,b));
-  }
-  else {
-    return 1;
-  }
+   if (!a.len && !strlen(b)) {
+      return 0;
+   }
+   else if (a.len && strlen(b)) {
+      return strcmp(a.str, b);
+   }
+   return 1;
 }
 
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-int strcmp(const Char_t* b,const VString& a)
+int strcmp(const char* b, const VString& a)
 {
-  if(a.len==0 && strlen(b)==0) {
-    return 0;
-  }
-  else if(a.len>0 && strlen(b)>0) {
-    return(strcmp(a.str,b));
-  }
-  else {
-    return 1;
-  }
+   if (!a.len && !strlen(b)) {
+      return 0;
+   }
+   else if (a.len && strlen(b)) {
+      return strcmp(a.str, b);
+   }
+   return 1;
 }
 
-#if 0
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-Char_t VString::operator[](Int_t index)
-{
-  if(len && 0<=index && index<len) return str[index];
-  else return 0;
-}
-
-///////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////
-char* strcpy(VString& a,const VString& b)
-{
-  a=b;
-}
-#endif

cint/test/VString.h

@@ -5,59 +5,68 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VString.h , C++
-*
-************************************************************************
-* Description:
-*
-***********************************************************************/
 
 #ifndef VSTRING_H
 #define VSTRING_H
 
 #include "VType.h"
 
-/***********************************************************************
-***********************************************************************/
-class VString {
- public:
-
-  VString() { len = 0; str = (Char_t*)NULL; }
-  VString(const Char_t* strIn);
-  VString(const VString& kstrIn);
-  VString& operator=(const VString& obj);
-  VString& operator=(const Char_t* s);
-  ~VString() { if(str) delete[] str; }
-  Int_t operator==(const VString& x) { 
-    if((0==len&&0==x.len) || (len==x.len && 0==strcmp(str,x.str))) 
-         return MATCH; 
-    else return UNMATCH;
-  }
-
-  Int_t Write(FILE* fp);
-  Int_t Read(FILE* fp);
-
-  void append(const VString& s);
-  void append(const Char_t* s);
-
-  Int_t Length() { return len; }
-  Char_t* String() { if(str) return str; else return "";}
-
-  friend int strcmp(const VString& a,const Char_t* b);
-  friend int strcmp(const Char_t* b,const VString& a);
-#if 0
-  Char_t operator[](Int_t index);
-  friend int strcmp(const VString& a,const VString& b);
-  friend char* strcpy(VString& a,const VString& b);
-#endif
-
- private: 
-  Int_t len;   
-  Char_t* str; 
-};
+class VString
+{
+   friend int strcmp(const VString& a, const char* b);
+   friend int strcmp(const char* b, const VString& a);
+
+public:
+
+   VString()
+   : len(0)
+   , str(0)
+   {
+   }
+
+   VString(const char* strIn);
+   VString(const VString& kstrIn);
+   VString& operator=(const VString& obj);
+   VString& operator=(const char* s);
+
+   ~VString()
+   {
+      delete[] str;
+   }
 
+   int operator==(const VString& x)
+   {
+      if (
+         (!len && !x.len) ||
+         ((len == x.len) && !strcmp(str, x.str))
+      ) {
+         return MATCH;
+      }
+      return UNMATCH;
+   }
 
+   int Write(FILE* fp);
+   int Read(FILE* fp);
 
-#endif // VString_H
+   void append(const VString& s);
+   void append(const char* s);
+
+   int Length()
+   {
+      return len;
+   }
+
+   const char* String()
+   {
+      if (str) {
+         return str;
+      }
+      return "";
+   }
+
+private:
+   int len;
+   char* str;
+};
 
+#endif // VSTRING_H

cint/test/VType.h

@@ -5,21 +5,14 @@
  * For the licensing terms see the file COPYING
  *
  ************************************************************************/
-/***********************************************************************
-* VType.h , C++
-*
-************************************************************************
-* Description:
-*
-***********************************************************************/
 
 #ifndef VTYPE_H
 #define VTYPE_H
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 
 #define SUCCESS 0
 #define FAILURE 1
@@ -45,4 +38,4 @@ typedef char Char_t;
 #define MATCH 1
 #define UNMATCH 0
 
-#endif
+#endif // VTYPE_H