毕向东java基础大纲

Standard_Integer awidthofbox;  // this is badStandard_Integer width_of_box; // this is badStandard_Integer aWidthOfBox;  // this is OK

<package-name>_<class-name>

typedef NCollection_IndexedDataMap<TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString> TColStd_IndexedDataMapOfStringString;

class MyPackage_MyClass{
public:
  Standard_Integer Value() const;  void             SetValue (const Standard_Integer theValue);
private:
  void setIntegerValue (const Standard_Integer theValue);
};

Standard_Integer Elapsed_Time = 0; // this is bad - possible class   nameStandard_Integer gp = 0;           // this is bad - existing package nameStandard_Integer aGp = 0;          // this is OKStandard_Integer _KERNEL = 0;      // this is badStandard_Integer THE_KERNEL = 0;   // this is OK

void Package_MyClass::MyFunction (const gp_Pnt& p);        // this is badvoid Package_MyClass::MyFunction (const gp_Pnt& theP);     // this is OKvoid Package_MyClass::MyFunction (const gp_Pnt& thePoint); // this is preferred

Standard_Integer counter;   // This is badStandard_Integer myC;       // This is OKStandard_Integer myCounter; // This is preferred

Standard_Integer MyPackage_myGlobalVariable = 0;Standard_Integer MyPackage_MyClass_myGlobalVariable = 0;

namespace{  static const Standard_Real THE_CONSTANT_COEF = 3.14;};

Standard_Integer theI;    // this is badStandard_Integer i;       // this is badStandard_Integer index;   // this is badStandard_Integer anIndex; // this is OK

void Average (const Standard_Real** theArray,              Standard_Integer      theRowsNb,              Standard_Integer      theRowLen,              Standard_Real&        theResult){  theResult = 0.0;  for (Standard_Integer aRow = 0; aRow < aRowsNb; ++aRow)  {    for (Standard_Integer aCol = 0; aCol < aRowLen; ++aCol)    {      theResult += theArray[aRow][aCol];    }    theResult /= Standard_Real(aRowsNb * aRowLen);  }}

while (true)                            // NOT: while( true ) ...{  DoSomething (theA, theB, theC, theD); // NOT: DoSomething(theA,theB,theC,theD);}for (anIter = 0; anIter < 10; ++anIter) // NOT: for (anIter=0;anIter<10;++anIter){{  theA = (theB + theC) * theD;          // NOT: theA=(theB+theC)*theD}

Standard_Integer   *theVariable;      // not recommendedStandard_Integer *  theVariable;      // not recommendedStandard_Integer*   theVariable;      // this is OK
Standard_Integer  *&theVariable;      // not recommendedStandard_Integer *& theVariable;      // not recommendedStandard_Integer*&  theVariable;      // this is OK
Standard_Integer  **theVariable;      // not recommendedStandard_Integer ** theVariable;      // not recommendedStandard_Integer**  theVariable;      // this is OK
Standard_Integer *theA, theB, **theC; // not recommended (declare each variable independently)

// check argumentsStandard_Integer anArgsNb = argCount();if (anArgsNb < 3 || isSmthInvalid){  return THE_ARG_INVALID;}
// read and check header......
// do our job......

// =======================================================================// function : TellMeSmthGood// purpose  : Gives me good news// =======================================================================void TellMeSmthGood(){  ...}
// =======================================================================// function : TellMeSmthBad// purpose  : Gives me bad news// =======================================================================void TellMeSmthBad(){  ...}

while (expression){  ...}

if (!myIsInit) return Standard_False; // bad
if (thePtr == NULL)                   // OK  return Standard_False;
if (!theAlgo.IsNull())                // preferred{  DoSomething();}

if (NULL != thePointer)    // Yoda style, not recommendedif (thePointer != NULL)    // OK
if (34 < anIter)           // Yoda style, not recommendedif (anIter > 34)           // OK
if (theNbValues >= anIter) // bad style (constant function argument vs. local variable)if (anIter <= theNbValues) // OK
if (THE_LIMIT == theValue) // bad style (global constant vs. variable)if (theValue == THE_LIMIT) // OK

MyPackage_MyClass anObject;Standard_Real     aMinimum = 0.0;Standard_Integer  aVal     = theVal;switch (aVal){  case 0:  computeSomething();              break;  case 12: computeSomethingElse (aMinimum); break;  case 3:  default: computeSomethingElseYet();       break;}

while (expression)   //bad comment{  // this is a long multi-line comment  // which is really required  DoSomething();     // maybe, enough  DoSomethingMore(); // again}

Standard_Integer ComputeSumm (const Standard_Integer* theArray,                              const Standard_Size     theSize){  Standard_Integer aSumm = 0;  if (theArray == NULL || theSize == 0)  {    return 0;  }
  ... computing summ ...  return aSumm;}

Standard_Integer ComputeSumm (const Standard_Integer* theArray,                              const Standard_Size     theSize){  Standard_Integer aSumm = 0;  if (theArray != NULL && theSize != 0)  {    ... computing summ ...  }  return aSumm;}

// the header file of implemented class#include <PackageName_ClassName.hxx>
// OCCT headers#include <gp_Pnt.hxx>#include <gp_Vec.hxx>#include <NCollection_List.hxx>
// Qt headers#include <QDataStream>#include <QString>
// system headers#include <iostream>#include <windows.h>

//! Method computes the square value.//! @param theValue the input value//! @return squared valueStandard_Export Standard_Real Square (Standard_Real theValue);

class MyPackage_BaseClass{
public:
  Standard_EXPORT virtual Standard_Boolean Perform();
};
class MyPackage_MyClass : public MyPackage_BaseClass{
public:
  Standard_EXPORT virtual Standard_Boolean Perform() Standard_OVERRIDE;
};

Standard_Real aMinDist = Precision::Infinite();for (NCollection_Sequence<gp_Pnt>::Iterator aPntIter (theSequence);     aPntIter.More(); aPntIter.Next()){  aMinDist = Min (aMinDist, theOrigin.Distance (aPntIter.Value()));

void Function (Standard_Integer theValue,               Standard_Real*   thePointer){  if (!theValue)          // bad style - ambiguous logic  {    DoSome();  }
  if (theValue == 0)      // OK  {    DoSome();  }
  if (thePointer != NULL) // OK, predefined NULL makes pointer comparison cleaner to reader  {                       // (nullptr should be used instead as soon as C++11 will be available)    DoSome2();  }}

class Slave;
class Master : public Standard_Transient{...  void SetSlave (const Handle(Slave)& theSlave){     mySlave = theSlave;  }...private:  Handle(Slave) theSlave; // smart pointer...}
class Slave : public Standard_Transient{...  void SetMaster (const Handle(Master)& theMaster){     myMaster = theMaster.get();  }...private:  Master* theMaster; // simple pointer...}

aPtr1 = new TypeA[n];              ... ; delete[]        aPtr1;aPtr2 = new TypeB();               ... ; delete          aPtr2;aPtr3 = Standard::Allocate (4096); ... ; Standard::Free (aPtr3);

Standard_Integer aTmpVar1;     // badStandard_Integer aTmpVar2 = 0; // OK

if (Abs (theFloat1 - theFloat2) < theTolerance){  DoSome();}

class MyPackage_MyClass{
public:
  MyPackage_MyClass()  : myPropertyA (1),    myPropertyB (2) {}
// NOT// : myPropertyB (2),//   myPropertyA (1) {}
private:
  Standard_Integer myPropertyA;  Standard_Integer myPropertyB;
};

MyPackage_MyClass(): myPropertyA (1)  // preferred{  myPropertyB = 2; // not recommended}

Standard_Real anArray[4096][2];for (Standard_Integer anIter = 0; anIter < 4096; ++anIter){  anArray[anIter][0] = anArray[anIter][1];}

Standard_Real anArray[2][4096];for (Standard_Integer anIter = 0; anIter < 4096; ++anIter){  anArray[0][anIter] = anArray[1][anIter];}

if (theArgsNb != 3){  std::cout << "Syntax error - wrong number of arguments!\n";  return 1;}
Standard_Integer anArgIter  = 1;Standard_CString aResName   = theArgVec[anArgIter++];Standard_CString aFaceName  = theArgVec[anArgIter++];TopoDS_Shape     aFaceShape = DBRep::Get (aFaceName);if (aFaceShape.IsNull() || aFaceShape.ShapeType() != TopAbs_FACE){  std::cout << "Shape " << aFaceName << " is empty or not a Face!\n";  return 1;}DBRep::Set (aResName, aFaceShape);return 0;

myCommand -flag1 value1 value2 -flag2 value3

Standard_Real aPosition[3] = {0.0, 0.0, 0.0};for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter){  Standard_CString anArg = theArgVec[anArgIter];  TCollection_AsciiString aFlag (anArg);  aFlag.LowerCase(); //!< for case insensitive comparison  if (aFlag == "position")  {    if ((anArgIt + 3) >= theArgsNb)    {      std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";      return 1;    }    aPosition[0] = Draw::Atof (theArgVec[++anArgIt]);    aPosition[1] = Draw::Atof (theArgVec[++anArgIt]);    aPosition[2] = Draw::Atof (theArgVec[++anArgIt]);  }  else  {    std::cout << "Syntax error! Unknown flag '" << anArg << "'\n";    return 1;  }}

class Package_Class{
public: //! @name public methods
  //! Method computes the square value.  //! @param theValue the input value  //! @return squared value  Standard_Export Standard_Real Square (const Standard_Real theValue);
private: //! \@name private methods
  //! Auxiliary method  void increment();
private: //! \@name private fields
  Standard_Integer myCounter; //!< usage counter
};#include <Package_Class.hxx>// ==========================================================// function : Square// purpose  : Method computes the square value// ==========================================================Standard_Real Package_Class::Square (const Standard_Real theValue){  increment();  return theValue * theValue;}
// ==========================================================// function : increment// purpose  :// ==========================================================void Package_Class::increment(){  ++myCounter;}

    1 # show fragments (solids) in shading with different colors    2 proc DisplayColored {theShape} {    3   set aSolids [uplevel #0 explode $theShape so]    4   set aColorIter 0    5   set THE_COLORS {red green blue1 magenta1 yellow cyan1 brown}    6   foreach aSolIter $aSolids {    7     uplevel #0 vdisplay         $aSolIter    8     uplevel #0 vsetcolor        $aSolIter [lindex $THE_COLORS [expr [incr aColorIter] % [llength $THE_COLORS]]]    9     uplevel #0 vsetdispmode     $aSolIter 1   10     uplevel #0 vsetmaterial     $aSolIter plastic   11     uplevel #0 vsettransparency $aSolIter 0.5   12   }   13 }   14    15 # load modules   16 pload MODELING VISUALIZATION   17    18 # create boxes   19 box bc  0 0 0 1 1 1   20 box br  1 0 0 1 1 2   21 compound bc br c   22    23 # show fragments (solids) in shading with different colors   24 vinit View1   25 vclear   26 vaxo   27 vzbufftrihedron   28 DisplayColored c   29 vfit   30 vdump $imagedir/${casename}.png 512 512

vec3 Ambient;  //!< Ambient  contribution of light sourcesvec3 Diffuse;  //!< Diffuse  contribution of light sourcesvec3 Specular; //!< Specular contribution of light sources
//! Computes illumination from light sourcesvec4 ComputeLighting (in vec3 theNormal,                      in vec3 theView,                      in vec4 thePoint){  // clear the light intensity accumulators  Ambient  = occLightAmbient.rgb;  Diffuse  = vec3 (0.0);  Specular = vec3 (0.0);  vec3 aPoint = thePoint.xyz / thePoint.w;  for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)  {    int aType = occLight_Type (anIndex);    if (aType == OccLightType_Direct)    {      directionalLight (anIndex, theNormal, theView);    }    else if (aType == OccLightType_Point)    {      pointLight (anIndex, theNormal, theView, aPoint);    }  }
  return vec4 (Ambient,  1.0) * occFrontMaterial_Ambient()       + vec4 (Diffuse,  1.0) * occFrontMaterial_Diffuse()       + vec4 (Specular, 1.0) * occFrontMaterial_Specular();}
//! Entry point to the Fragment Shadervoid main(){  gl_FragColor = computeLighting (normalize (Normal),                                  normalize (View),                                  Position);}