moruite

C++的JSON库及使用方法

VC没有自带的JSON库，所以分享一下如何使用该库http://download.csdn.net/detail/moruite/4104704

1. json.h头文件包含了如下API

#ifndef CPPTL_JSON_H_INCLUDED
# define CPPTL_JSON_H_INCLUDED

# include "forwards.h"
# include 
# include 

# ifndef JSON_USE_CPPTL_SMALLMAP
#  include 
# else
#  include 
# endif
# ifdef JSON_USE_CPPTL
#  include 
# endif

/** \brief JSON (JavaScript Object Notation).
 */
namespace Json {

   /** \brief Type of the value held by a Value object.
    */
   enum ValueType
   {
      nullValue = 0, ///< 'null' value
      intValue,      ///< signed integer value
      uintValue,     ///< unsigned integer value
      realValue,     ///< double value
      stringValue,   ///< UTF-8 string value
      booleanValue,  ///< bool value
      arrayValue,    ///< array value (ordered list)
      objectValue    ///< object value (collection of name/value pairs).
   };

   enum CommentPlacement
   {
      commentBefore = 0,        ///< a comment placed on the line before a value
      commentAfterOnSameLine,   ///< a comment just after a value on the same line
      commentAfter,             ///< a comment on the line after a value (only make sense for root value)
      numberOfCommentPlacement
   };

//# ifdef JSON_USE_CPPTL
//   typedef CppTL::AnyEnumerator EnumMemberNames;
//   typedef CppTL::AnyEnumerator EnumValues;
//# endif

   /** \brief Lightweight wrapper to tag static string.
    *
    * Value constructor and objectValue member assignement takes advantage of the
    * StaticString and avoid the cost of string duplication when storing the
    * string or the member name.
    *
    * Example of usage:
    * \code
    * Json::Value aValue( StaticString("some text") );
    * Json::Value object;
    * static const StaticString code("code");
    * object[code] = 1234;
    * \endcode
    */
   class JSON_API StaticString
   {
   public:
      explicit StaticString( const char *czstring )
         : str_( czstring )
      {
      }

      operator const char *() const
      {
         return str_;
      }

      const char *c_str() const
      {
         return str_;
      }

   private:
      const char *str_;
   };

   /** \brief Represents a JSON value.
    *
    * This class is a discriminated union wrapper that can represents a:
    * - signed integer [range: Value::minInt - Value::maxInt]
    * - unsigned integer (range: 0 - Value::maxUInt)
    * - double
    * - UTF-8 string
    * - boolean
    * - 'null'
    * - an ordered list of Value
    * - collection of name/value pairs (javascript object)
    *
    * The type of the held value is represented by a #ValueType and 
    * can be obtained using type().
    *
    * values of an #objectValue or #arrayValue can be accessed using operator[]() methods. 
    * Non const methods will automatically create the a #nullValue element 
    * if it does not exist. 
    * The sequence of an #arrayValue will be automatically resize and initialized 
    * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
    *
    * The get() methods can be used to obtanis default value in the case the required element
    * does not exist.
    *
    * It is possible to iterate over the list of a #objectValue values using 
    * the getMemberNames() method.
    */
   class JSON_API Value 
   {
      friend class ValueIteratorBase;
# ifdef JSON_VALUE_USE_INTERNAL_MAP
      friend class ValueInternalLink;
      friend class ValueInternalMap;
# endif
   public:
      typedef std::vector Members;
      typedef ValueIterator iterator;
      typedef ValueConstIterator const_iterator;
      typedef Json::UInt UInt;
      typedef Json::Int Int;
      typedef UInt ArrayIndex;

      static const Value null;
      static const Int minInt;
      static const Int maxInt;
      static const UInt maxUInt;

   private:
#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
# ifndef JSON_VALUE_USE_INTERNAL_MAP
      class CZString 
      {
      public:
         enum DuplicationPolicy 
         {
            noDuplication = 0,
            duplicate,
            duplicateOnCopy
         };
         CZString( int index );
         CZString( const char *cstr, DuplicationPolicy allocate );
         CZString( const CZString &other );
         ~CZString();
         CZString &operator =( const CZString &other );
         bool operator<( const CZString &other ) const;
         bool operator==( const CZString &other ) const;
         int index() const;
         const char *c_str() const;
         bool isStaticString() const;
      private:
         void swap( CZString &other );
         const char *cstr_;
         int index_;
      };

   public:
#  ifndef JSON_USE_CPPTL_SMALLMAP
      typedef std::map ObjectValues;
#  else
      typedef CppTL::SmallMap ObjectValues;
#  endif // ifndef JSON_USE_CPPTL_SMALLMAP
# endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

   public:
      /** \brief Create a default Value of the given type.

        This is a very useful constructor.
        To create an empty array, pass arrayValue.
        To create an empty object, pass objectValue.
        Another Value can then be set to this one by assignment.
	This is useful since clear() and resize() will not alter types.

        Examples:
	\code
	Json::Value null_value; // null
	Json::Value arr_value(Json::arrayValue); // []
	Json::Value obj_value(Json::objectValue); // {}
	\endcode
      */
      Value( ValueType type = nullValue );
      Value( Int value );
      Value( UInt value );
      Value( double value );
      Value( const char *value );
      Value( const char *beginValue, const char *endValue );
      /** \brief Constructs a value from a static string.

       * Like other value string constructor but do not duplicate the string for
       * internal storage. The given string must remain alive after the call to this
       * constructor.
       * Example of usage:
       * \code
       * Json::Value aValue( StaticString("some text") );
       * \endcode
       */
      Value( const StaticString &value );
      Value( const std::string &value );
# ifdef JSON_USE_CPPTL
      Value( const CppTL::ConstString &value );
# endif
      Value( bool value );
      Value( const Value &other );
      ~Value();

      Value &operator=( const Value &other );
      /// Swap values.
      /// \note Currently, comments are intentionally not swapped, for
      /// both logic and efficiency.
      void swap( Value &other );

      ValueType type() const;

      bool operator <( const Value &other ) const;
      bool operator <=( const Value &other ) const;
      bool operator >=( const Value &other ) const;
      bool operator >( const Value &other ) const;

      bool operator ==( const Value &other ) const;
      bool operator !=( const Value &other ) const;

      int compare( const Value &other );

      const char *asCString() const;
      std::string asString() const;
# ifdef JSON_USE_CPPTL
      CppTL::ConstString asConstString() const;
# endif
      Int asInt() const;
      UInt asUInt() const;
      double asDouble() const;
      bool asBool() const;

      bool isNull() const;
      bool isBool() const;
      bool isInt() const;
      bool isUInt() const;
      bool isIntegral() const;
      bool isDouble() const;
      bool isNumeric() const;
      bool isString() const;
      bool isArray() const;
      bool isObject() const;

      bool isConvertibleTo( ValueType other ) const;

      /// Number of values in array or object
      UInt size() const;

      /// \brief Return true if empty array, empty object, or null;
      /// otherwise, false.
      bool empty() const;

      /// Return isNull()
      bool operator!() const;

      /// Remove all object members and array elements.
      /// \pre type() is arrayValue, objectValue, or nullValue
      /// \post type() is unchanged
      void clear();

      /// Resize the array to size elements. 
      /// New elements are initialized to null.
      /// May only be called on nullValue or arrayValue.
      /// \pre type() is arrayValue or nullValue
      /// \post type() is arrayValue
      void resize( UInt size );

      /// Access an array element (zero based index ).
      /// If the array contains less than index element, then null value are inserted
      /// in the array so that its size is index+1.
      /// (You may need to say 'value[0u]' to get your compiler to distinguish
      ///  this from the operator[] which takes a string.)
      Value &operator[]( UInt index );
      /// Access an array element (zero based index )
      /// (You may need to say 'value[0u]' to get your compiler to distinguish
      ///  this from the operator[] which takes a string.)
      const Value &operator[]( UInt index ) const;
      /// If the array contains at least index+1 elements, returns the element value, 
      /// otherwise returns defaultValue.
      Value get( UInt index, 
                 const Value &defaultValue ) const;
      /// Return true if index < size().
      bool isValidIndex( UInt index ) const;
      /// \brief Append value to array at the end.
      ///
      /// Equivalent to jsonvalue[jsonvalue.size()] = value;
      Value &append( const Value &value );

      /// Access an object value by name, create a null member if it does not exist.
      Value &operator[]( const char *key );
      /// Access an object value by name, returns null if there is no member with that name.
      const Value &operator[]( const char *key ) const;
      /// Access an object value by name, create a null member if it does not exist.
      Value &operator[]( const std::string &key );
      /// Access an object value by name, returns null if there is no member with that name.
      const Value &operator[]( const std::string &key ) const;
      /** \brief Access an object value by name, create a null member if it does not exist.

       * If the object as no entry for that name, then the member name used to store
       * the new entry is not duplicated.
       * Example of use:
       * \code
       * Json::Value object;
       * static const StaticString code("code");
       * object[code] = 1234;
       * \endcode
       */
      Value &operator[]( const StaticString &key );
# ifdef JSON_USE_CPPTL
      /// Access an object value by name, create a null member if it does not exist.
      Value &operator[]( const CppTL::ConstString &key );
      /// Access an object value by name, returns null if there is no member with that name.
      const Value &operator[]( const CppTL::ConstString &key ) const;
# endif
      /// Return the member named key if it exist, defaultValue otherwise.
      Value get( const char *key, 
                 const Value &defaultValue ) const;
      /// Return the member named key if it exist, defaultValue otherwise.
      Value get( const std::string &key,
                 const Value &defaultValue ) const;
# ifdef JSON_USE_CPPTL
      /// Return the member named key if it exist, defaultValue otherwise.
      Value get( const CppTL::ConstString &key,
                 const Value &defaultValue ) const;
# endif
      /// \brief Remove and return the named member.  
      ///
      /// Do nothing if it did not exist.
      /// \return the removed Value, or null.
      /// \pre type() is objectValue or nullValue
      /// \post type() is unchanged
      Value removeMember( const char* key );
      /// Same as removeMember(const char*)
      Value removeMember( const std::string &key );

      /// Return true if the object has a member named key.
      bool isMember( const char *key ) const;
      /// Return true if the object has a member named key.
      bool isMember( const std::string &key ) const;
# ifdef JSON_USE_CPPTL
      /// Return true if the object has a member named key.
      bool isMember( const CppTL::ConstString &key ) const;
# endif

      /// \brief Return a list of the member names.
      ///
      /// If null, return an empty list.
      /// \pre type() is objectValue or nullValue
      /// \post if type() was nullValue, it remains nullValue
      Members getMemberNames() const;

//# ifdef JSON_USE_CPPTL
//      EnumMemberNames enumMemberNames() const;
//      EnumValues enumValues() const;
//# endif

      /// Comments must be //... or /* ... */
      void setComment( const char *comment,
                       CommentPlacement placement );
      /// Comments must be //... or /* ... */
      void setComment( const std::string &comment,
                       CommentPlacement placement );
      bool hasComment( CommentPlacement placement ) const;
      /// Include delimiters and embedded newlines.
      std::string getComment( CommentPlacement placement ) const;

      std::string toStyledString() const;

      const_iterator begin() const;
      const_iterator end() const;

      iterator begin();
      iterator end();

   private:
      Value &resolveReference( const char *key, 
                               bool isStatic );

# ifdef JSON_VALUE_USE_INTERNAL_MAP
      inline bool isItemAvailable() const
      {
         return itemIsUsed_ == 0;
      }

      inline void setItemUsed( bool isUsed = true )
      {
         itemIsUsed_ = isUsed ? 1 : 0;
      }

      inline bool isMemberNameStatic() const
      {
         return memberNameIsStatic_ == 0;
      }

      inline void setMemberNameIsStatic( bool isStatic )
      {
         memberNameIsStatic_ = isStatic ? 1 : 0;
      }
# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP

   private:
      struct CommentInfo
      {
         CommentInfo();
         ~CommentInfo();

         void setComment( const char *text );

         char *comment_;
      };

      //struct MemberNamesTransform
      //{
      //   typedef const char *result_type;
      //   const char *operator()( const CZString &name ) const
      //   {
      //      return name.c_str();
      //   }
      //};

      union ValueHolder
      {
         Int int_;
         UInt uint_;
         double real_;
         bool bool_;
         char *string_;
# ifdef JSON_VALUE_USE_INTERNAL_MAP
         ValueInternalArray *array_;
         ValueInternalMap *map_;
#else
         ObjectValues *map_;
# endif
      } value_;
      ValueType type_ : 8;
      int allocated_ : 1;     // Notes: if declared as bool, bitfield is useless.
# ifdef JSON_VALUE_USE_INTERNAL_MAP
      unsigned int itemIsUsed_ : 1;      // used by the ValueInternalMap container.
      int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
# endif
      CommentInfo *comments_;
   };


   /** \brief Experimental and untested: represents an element of the "path" to access a node.
    */
   class PathArgument
   {
   public:
      friend class Path;

      PathArgument();
      PathArgument( UInt index );
      PathArgument( const char *key );
      PathArgument( const std::string &key );

   private:
      enum Kind
      {
         kindNone = 0,
         kindIndex,
         kindKey
      };
      std::string key_;
      UInt index_;
      Kind kind_;
   };

   /** \brief Experimental and untested: represents a "path" to access a node.
    *
    * Syntax:
    * - "." => root node
    * - ".[n]" => elements at index 'n' of root node (an array value)
    * - ".name" => member named 'name' of root node (an object value)
    * - ".name1.name2.name3"
    * - ".[0][1][2].name1[3]"
    * - ".%" => member name is provided as parameter
    * - ".[%]" => index is provied as parameter
    */
   class Path
   {
   public:
      Path( const std::string &path,
            const PathArgument &a1 = PathArgument(),
            const PathArgument &a2 = PathArgument(),
            const PathArgument &a3 = PathArgument(),
            const PathArgument &a4 = PathArgument(),
            const PathArgument &a5 = PathArgument() );

      const Value &resolve( const Value &root ) const;
      Value resolve( const Value &root, 
                     const Value &defaultValue ) const;
      /// Creates the "path" to access the specified node and returns a reference on the node.
      Value &make( Value &root ) const;

   private:
      typedef std::vector InArgs;
      typedef std::vector Args;

      void makePath( const std::string &path,
                     const InArgs &in );
      void addPathInArg( const std::string &path, 
                         const InArgs &in, 
                         InArgs::const_iterator &itInArg, 
                         PathArgument::Kind kind );
      void invalidPath( const std::string &path, 
                        int location );

      Args args_;
   };

   /** \brief Experimental do not use: Allocator to customize member name and string value memory management done by Value.
    *
    * - makeMemberName() and releaseMemberName() are called to respectively duplicate and
    *   free an Json::objectValue member name.
    * - duplicateStringValue() and releaseStringValue() are called similarly to
    *   duplicate and free a Json::stringValue value.
    */
   class ValueAllocator
   {
   public:
      enum { unknown = (unsigned)-1 };

      virtual ~ValueAllocator();

      virtual char *makeMemberName( const char *memberName ) = 0;
      virtual void releaseMemberName( char *memberName ) = 0;
      virtual char *duplicateStringValue( const char *value, 
                                          unsigned int length = unknown ) = 0;
      virtual void releaseStringValue( char *value ) = 0;
   };

#ifdef JSON_VALUE_USE_INTERNAL_MAP
   /** \brief Allocator to customize Value internal map.
    * Below is an example of a simple implementation (default implementation actually
    * use memory pool for speed).
    * \code
      class DefaultValueMapAllocator : public ValueMapAllocator
      {
      public: // overridden from ValueMapAllocator
         virtual ValueInternalMap *newMap()
         {
            return new ValueInternalMap();
         }

         virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
         {
            return new ValueInternalMap( other );
         }

         virtual void destructMap( ValueInternalMap *map )
         {
            delete map;
         }

         virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
         {
            return new ValueInternalLink[size];
         }

         virtual void releaseMapBuckets( ValueInternalLink *links )
         {
            delete [] links;
         }

         virtual ValueInternalLink *allocateMapLink()
         {
            return new ValueInternalLink();
         }

         virtual void releaseMapLink( ValueInternalLink *link )
         {
            delete link;
         }
      };
    * \endcode
    */ 
   class JSON_API ValueMapAllocator
   {
   public:
      virtual ~ValueMapAllocator();
      virtual ValueInternalMap *newMap() = 0;
      virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
      virtual void destructMap( ValueInternalMap *map ) = 0;
      virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
      virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
      virtual ValueInternalLink *allocateMapLink() = 0;
      virtual void releaseMapLink( ValueInternalLink *link ) = 0;
   };

   /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
    * \internal previous_ & next_ allows for bidirectional traversal.
    */
   class JSON_API ValueInternalLink
   {
   public:
      enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
      enum InternalFlags { 
         flagAvailable = 0,
         flagUsed = 1
      };

      ValueInternalLink();

      ~ValueInternalLink();

      Value items_[itemPerLink];
      char *keys_[itemPerLink];
      ValueInternalLink *previous_;
      ValueInternalLink *next_;
   };


   /** \brief A linked page based hash-table implementation used internally by Value.
    * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
    * list in each bucket to handle collision. There is an addional twist in that
    * each node of the collision linked list is a page containing a fixed amount of
    * value. This provides a better compromise between memory usage and speed.
    * 
    * Each bucket is made up of a chained list of ValueInternalLink. The last
    * link of a given bucket can be found in the 'previous_' field of the following bucket.
    * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
    * Only the last link of a bucket may contains 'available' item. The last link always
    * contains at least one element unless is it the bucket one very first link.
    */
   class JSON_API ValueInternalMap
   {
      friend class ValueIteratorBase;
      friend class Value;
   public:
      typedef unsigned int HashKey;
      typedef unsigned int BucketIndex;

# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
      struct IteratorState
      {
         IteratorState() 
            : map_(0)
            , link_(0)
            , itemIndex_(0)
            , bucketIndex_(0) 
         {
         }
         ValueInternalMap *map_;
         ValueInternalLink *link_;
         BucketIndex itemIndex_;
         BucketIndex bucketIndex_;
      };
# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

      ValueInternalMap();
      ValueInternalMap( const ValueInternalMap &other );
      ValueInternalMap &operator =( const ValueInternalMap &other );
      ~ValueInternalMap();

      void swap( ValueInternalMap &other );

      BucketIndex size() const;

      void clear();

      bool reserveDelta( BucketIndex growth );

      bool reserve( BucketIndex newItemCount );

      const Value *find( const char *key ) const;

      Value *find( const char *key );

      Value &resolveReference( const char *key, 
                               bool isStatic );

      void remove( const char *key );

      void doActualRemove( ValueInternalLink *link, 
                           BucketIndex index,
                           BucketIndex bucketIndex );

      ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );

      Value &setNewItem( const char *key, 
                         bool isStatic, 
                         ValueInternalLink *link, 
                         BucketIndex index );

      Value &unsafeAdd( const char *key, 
                        bool isStatic, 
                        HashKey hashedKey );

      HashKey hash( const char *key ) const;

      int compare( const ValueInternalMap &other ) const;

   private:
      void makeBeginIterator( IteratorState &it ) const;
      void makeEndIterator( IteratorState &it ) const;
      static bool equals( const IteratorState &x, const IteratorState &other );
      static void increment( IteratorState &iterator );
      static void incrementBucket( IteratorState &iterator );
      static void decrement( IteratorState &iterator );
      static const char *key( const IteratorState &iterator );
      static const char *key( const IteratorState &iterator, bool &isStatic );
      static Value &value( const IteratorState &iterator );
      static int distance( const IteratorState &x, const IteratorState &y );

   private:
      ValueInternalLink *buckets_;
      ValueInternalLink *tailLink_;
      BucketIndex bucketsSize_;
      BucketIndex itemCount_;
   };

   /** \brief A simplified deque implementation used internally by Value.
   * \internal
   * It is based on a list of fixed "page", each page contains a fixed number of items.
   * Instead of using a linked-list, a array of pointer is used for fast item look-up.
   * Look-up for an element is as follow:
   * - compute page index: pageIndex = itemIndex / itemsPerPage
   * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
   *
   * Insertion is amortized constant time (only the array containing the index of pointers
   * need to be reallocated when items are appended).
   */
   class JSON_API ValueInternalArray
   {
      friend class Value;
      friend class ValueIteratorBase;
   public:
      enum { itemsPerPage = 8 };    // should be a power of 2 for fast divide and modulo.
      typedef Value::ArrayIndex ArrayIndex;
      typedef unsigned int PageIndex;

# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
      struct IteratorState // Must be a POD
      {
         IteratorState() 
            : array_(0)
            , currentPageIndex_(0)
            , currentItemIndex_(0) 
         {
         }
         ValueInternalArray *array_;
         Value **currentPageIndex_;
         unsigned int currentItemIndex_;
      };
# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

      ValueInternalArray();
      ValueInternalArray( const ValueInternalArray &other );
      ValueInternalArray &operator =( const ValueInternalArray &other );
      ~ValueInternalArray();
      void swap( ValueInternalArray &other );

      void clear();
      void resize( ArrayIndex newSize );

      Value &resolveReference( ArrayIndex index );

      Value *find( ArrayIndex index ) const;

      ArrayIndex size() const;

      int compare( const ValueInternalArray &other ) const;

   private:
      static bool equals( const IteratorState &x, const IteratorState &other );
      static void increment( IteratorState &iterator );
      static void decrement( IteratorState &iterator );
      static Value &dereference( const IteratorState &iterator );
      static Value &unsafeDereference( const IteratorState &iterator );
      static int distance( const IteratorState &x, const IteratorState &y );
      static ArrayIndex indexOf( const IteratorState &iterator );
      void makeBeginIterator( IteratorState &it ) const;
      void makeEndIterator( IteratorState &it ) const;
      void makeIterator( IteratorState &it, ArrayIndex index ) const;

      void makeIndexValid( ArrayIndex index );

      Value **pages_;
      ArrayIndex size_;
      PageIndex pageCount_;
   };

   /** \brief Experimental: do not use. Allocator to customize Value internal array.
    * Below is an example of a simple implementation (actual implementation use
    * memory pool).
      \code
class DefaultValueArrayAllocator : public ValueArrayAllocator
{
public: // overridden from ValueArrayAllocator
   virtual ~DefaultValueArrayAllocator()
   {
   }

   virtual ValueInternalArray *newArray()
   {
      return new ValueInternalArray();
   }

   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
   {
      return new ValueInternalArray( other );
   }

   virtual void destruct( ValueInternalArray *array )
   {
      delete array;
   }

   virtual void reallocateArrayPageIndex( Value **&indexes, 
                                          ValueInternalArray::PageIndex &indexCount,
                                          ValueInternalArray::PageIndex minNewIndexCount )
   {
      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
      if ( minNewIndexCount > newIndexCount )
         newIndexCount = minNewIndexCount;
      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
      if ( !newIndexes )
         throw std::bad_alloc();
      indexCount = newIndexCount;
      indexes = static_cast( newIndexes );
   }
   virtual void releaseArrayPageIndex( Value **indexes, 
                                       ValueInternalArray::PageIndex indexCount )
   {
      if ( indexes )
         free( indexes );
   }

   virtual Value *allocateArrayPage()
   {
      return static_cast( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
   }

   virtual void releaseArrayPage( Value *value )
   {
      if ( value )
         free( value );
   }
};
      \endcode
    */ 
   class JSON_API ValueArrayAllocator
   {
   public:
      virtual ~ValueArrayAllocator();
      virtual ValueInternalArray *newArray() = 0;
      virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
      virtual void destructArray( ValueInternalArray *array ) = 0;
      /** \brief Reallocate array page index.
       * Reallocates an array of pointer on each page.
       * \param indexes [input] pointer on the current index. May be \c NULL.
       *                [output] pointer on the new index of at least 
       *                         \a minNewIndexCount pages. 
       * \param indexCount [input] current number of pages in the index.
       *                   [output] number of page the reallocated index can handle.
       *                            \b MUST be >= \a minNewIndexCount.
       * \param minNewIndexCount Minimum number of page the new index must be able to
       *                         handle.
       */
      virtual void reallocateArrayPageIndex( Value **&indexes, 
                                             ValueInternalArray::PageIndex &indexCount,
                                             ValueInternalArray::PageIndex minNewIndexCount ) = 0;
      virtual void releaseArrayPageIndex( Value **indexes, 
                                          ValueInternalArray::PageIndex indexCount ) = 0;
      virtual Value *allocateArrayPage() = 0;
      virtual void releaseArrayPage( Value *value ) = 0;
   };
#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP


   /** \brief base class for Value iterators.
    *
    */
   class ValueIteratorBase
   {
   public:
      typedef unsigned int size_t;
      typedef int difference_type;
      typedef ValueIteratorBase SelfType;

      ValueIteratorBase();
#ifndef JSON_VALUE_USE_INTERNAL_MAP
      explicit ValueIteratorBase( const Value::ObjectValues::iterator ¤t );
#else
      ValueIteratorBase( const ValueInternalArray::IteratorState &state );
      ValueIteratorBase( const ValueInternalMap::IteratorState &state );
#endif

      bool operator ==( const SelfType &other ) const
      {
         return isEqual( other );
      }

      bool operator !=( const SelfType &other ) const
      {
         return !isEqual( other );
      }

      difference_type operator -( const SelfType &other ) const
      {
         return computeDistance( other );
      }

      /// Return either the index or the member name of the referenced value as a Value.
      Value key() const;

      /// Return the index of the referenced Value. -1 if it is not an arrayValue.
      UInt index() const;

      /// Return the member name of the referenced Value. "" if it is not an objectValue.
      const char *memberName() const;

   protected:
      Value &deref() const;

      void increment();

      void decrement();

      difference_type computeDistance( const SelfType &other ) const;

      bool isEqual( const SelfType &other ) const;

      void copy( const SelfType &other );

   private:
#ifndef JSON_VALUE_USE_INTERNAL_MAP
      Value::ObjectValues::iterator current_;
      // Indicates that iterator is for a null value.
      bool isNull_;
#else
      union
      {
         ValueInternalArray::IteratorState array_;
         ValueInternalMap::IteratorState map_;
      } iterator_;
      bool isArray_;
#endif
   };

   /** \brief const iterator for object and array value.
    *
    */
   class ValueConstIterator : public ValueIteratorBase
   {
      friend class Value;
   public:
      typedef unsigned int size_t;
      typedef int difference_type;
      typedef const Value &reference;
      typedef const Value *pointer;
      typedef ValueConstIterator SelfType;

      ValueConstIterator();
   private:
      /*! \internal Use by Value to create an iterator.
       */
#ifndef JSON_VALUE_USE_INTERNAL_MAP
      explicit ValueConstIterator( const Value::ObjectValues::iterator ¤t );
#else
      ValueConstIterator( const ValueInternalArray::IteratorState &state );
      ValueConstIterator( const ValueInternalMap::IteratorState &state );
#endif
   public:
      SelfType &operator =( const ValueIteratorBase &other );

      SelfType operator++( int )
      {
         SelfType temp( *this );
         ++*this;
         return temp;
      }

      SelfType operator--( int )
      {
         SelfType temp( *this );
         --*this;
         return temp;
      }

      SelfType &operator--()
      {
         decrement();
         return *this;
      }

      SelfType &operator++()
      {
         increment();
         return *this;
      }

      reference operator *() const
      {
         return deref();
      }
   };


   /** \brief Iterator for object and array value.
    */
   class ValueIterator : public ValueIteratorBase
   {
      friend class Value;
   public:
      typedef unsigned int size_t;
      typedef int difference_type;
      typedef Value &reference;
      typedef Value *pointer;
      typedef ValueIterator SelfType;

      ValueIterator();
      ValueIterator( const ValueConstIterator &other );
      ValueIterator( const ValueIterator &other );
   private:
      /*! \internal Use by Value to create an iterator.
       */
#ifndef JSON_VALUE_USE_INTERNAL_MAP
      explicit ValueIterator( const Value::ObjectValues::iterator ¤t );
#else
      ValueIterator( const ValueInternalArray::IteratorState &state );
      ValueIterator( const ValueInternalMap::IteratorState &state );
#endif
   public:

      SelfType &operator =( const SelfType &other );

      SelfType operator++( int )
      {
         SelfType temp( *this );
         ++*this;
         return temp;
      }

      SelfType operator--( int )
      {
         SelfType temp( *this );
         --*this;
         return temp;
      }

      SelfType &operator--()
      {
         decrement();
         return *this;
      }

      SelfType &operator++()
      {
         increment();
         return *this;
      }

      reference operator *() const
      {
         return deref();
      }
   };


} // namespace Json


#endif // CPPTL_JSON_H_INCLUDED

2. 如何打包json数据

Json::Value rootNode;
	Json::Value listNode;

	for(i=0;i

 
  
 3. 如何解析json数据 
   
  Json::Value result;
		Json::Reader reader;
		
		if(!reader.parse((LPTSTR)(LPCTSTR)strContent,result)){
			return FALSE;
		}

		

		//m_MachineId.Format("%s",result["machineId"]);
		m_MachineId=result["machineId"].asCString();
		m_TableId=result["tableId"].asCString();
		m_StreamLine=result["streamLine"].asCString();
		m_PersonCount=result["personCount"].asCString();
        double totalPrice=0;
		Json::Value list=result["dishItem"];
		if(list.isArray()){
			int count=list.size();
			Json::Value element;
			for(int i=0;idishUnit=element["dishUnit"].asCString();
				pItem->dishMake=element["dishMake"].asCString();
				pItem->dishId=element["dishId"].asCString();
				pItem->dishName=element["dishName"].asCString();
				pItem->dishNum.Format("%d",element["dishNum"].asInt());
				pItem->dishPrice=element["dishPrice"].asCString();
				totalPrice+=atof(element["dishPrice"].asCString());
				m_Items.AddTail(pItem);

			}

		}
		m_Price.Format("%.2f",totalPrice);

VS中x86（x32）,x64,any CPU，Debug和Release的区别 Conchpeng 学习资料[非纸质]
x86（x32）,x64,AnyCPU之间的联系x86编译的.exe或者dll都是32位的，x64是64位的，AnyCPU是根据操作系统决定dll必须与调用它的主程序保持一致但是由AnyCPU生成的dll，也会保持生成它的主程序的性质：随平台（此时是调用它的主程序）改变而改变。也就是说，若dll由AnyCPU编译的，可以任意被x86或者x64主程序调用Debug和Release的区别调试版本、运行
【国产自研-神软大数据平台3.4.10】王旭亮_ 数据治理大数据技术栈大数据数据治理神软产品国产自研
产品介绍：北京神舟航天软件技术股份有限公司自研全栈式大数据平台神软大数据平台是数据全生命周期一站式数据治理开发平台，提供数据采集、数据集成、数据开发、数据治理、数据服务等功能，支持大数据存储、大数据计算分析引擎等数据底座，充分发挥数据价值作用，聚焦企业数字化转型，提升组织的信息化水平和高效应用决策。1、可以兼容并适配各种服务器（X86\ARM）、操作系统包括Centos、麒麟V10SP3、欧拉（o
使用OpenCV在Visual Studio上编译x86或x64平台的应用程序程序世界航海 opencv visual studio 人工智能编程
OpenCV是一个广泛使用的计算机视觉库，它提供了丰富的图像处理和计算机视觉算法。如果你想在VisualStudio上编译一个使用OpenCV的应用程序，并且需要针对特定的x86或x64平台进行优化，那么本文将为你提供一些指导。以下是在VisualStudio中编译x86或x64平台上的OpenCV应用程序的步骤：步骤1：安装VisualStudio和OpenCV首先，确保你已经安装了最新版本的V
2025广州国际汽车内外饰技术展览会：引领汽车内外饰发展新潮流-Automotive Interiors JSZNZZ 汽车制造科技
随着科技的不断进步和消费者对汽车品质的要求日益提高，汽车内外饰的设计和制造也在不断创新和发展。AUTOTECHChina2025广州国际汽车内外饰技术展览会作为行业内的重要盛会，将于2025年11月20日至22日在广州保利世贸博览馆盛大举办。本次展览会将汇集全球500多家领先参展商，展示最新的汽车内外饰设计、材料、制造和生产设备、信息娱乐系统等方面的产品和服务，为汽车行业的发展提供一个重要的交流与
功率半导体展聚焦 APSME 2025，共探功率半导体发展新征程 JSZNZZ 制造信息与通信可用性测试
在科技迭代的滚滚浪潮中，功率半导体作为现代工业的“心脏”，其重要性愈发凸显。2025年11月20-22日，APSME2025亚洲国际功率半导体、材料及装备技术展览会将在广州保利世贸博览馆隆重举办，这不仅是一场行业的年度盛事，更是功率半导体领域迈向未来的关键契机。近年来，功率半导体凭借其独特优势，在众多领域发挥着核心作用。在新能源汽车领域，功率半导体是实现电能高效转换的关键，直接影响着汽车的续航里程
机器学习和线性回归、softmax回归小名叫咸菜人工智能线性回归
监督学习监督学习（supervisedlearning）擅⻓在“给定输⼊特征”的情况下预测标签。每个“特征-标签”对都称为一个样本（example）。我们的目标是生成一个模型，能够将任何输⼊特征映射到标签（即预测）。回归——平方误差损失函数回归（regression）是最简单的监督学习任务之一。分类——交叉熵样本属于“哪一类”的问题称为分类问题回归是训练一个回归函数来输出一个数值；分类是训练一个分
首都国际会展中心启用，首展聚焦汽车后市场全产业链 2401_89023604 汽车人工智能大数据
首都国际会展中心启用，首展聚焦汽车后市场全产业链2025年2月21日-24日，首都国际会展中心（新国展二期）迎来了其启用后的首场大型展览——第36届中国国际汽车服务用品及设备展览会暨中国国际新能源汽车技术、零部件及服务展览会（雅森北京展）。此次展览不仅是汽车后市场全产业链的开年第一展，更是新展馆投入使用的里程碑事件。作为北京市单体规模最大、功能最完善、技术最先进的综合型会展场馆，新国展二期经过三年
腾讯云点播Web端上传视频+SDK使用
官方链接：Web端上传SDK腾讯云控制台客户端上传签名签名生成示例1、Web端嵌入云点播SDK//安装稳定版本npminstallvod-js-sdk-v6在对应的页面引入importTcVodfrom'vod-js-sdk-v6'入完成后，需要生成签名，签名需要通过SecretId、SecretKey来生成SecretId、SecretKey生成：腾讯云控制台进入云控制台后，点击新建密钥：获取到
未来网络的高速引擎：800G光模块市场预测与应用前景益莱储中国信息与通信
近年来，VR、物联网、云计算等新业务的出现，对网络带宽、并发、实时性能提出了更高的要求。随着带宽需求持续飙升，100G、200G和400G光模块将保持重要的市场份额，800G光模块也将获得吸引力。800G光模块是AI算力产业链上的重要环节。随着AI算力需求的激增，800G光模块等高速光模块的需求显著增长，其市场规模也有望进一步扩大。光通信行业市场研究机构LightCounting指出，2022至2
盘点：哪些科技公司接入了DeepSeek，它们在做什么？人工智能深度学习
在人工智能蓬勃发展的当下，DeepSeek以其独特的技术优势和创新理念，吸引了众多科技公司的目光，成为行业内广泛接入的对象。这些公司与DeepSeek的合作，不仅为自身业务注入了新的活力，也推动了AI技术在更多领域的落地应用。下面，就让我们一同盘点接入DeepSeek的科技公司及其接入情况和功能。互联网巨头：百度与腾讯百度：搜索与智能体平台的全面升级2月16日晚，百度搜索和文心智能体平台宣布全面接
昆仑万维发布Matrix-Zero世界模型，开启空间智能新时代 3d
2月14日，昆仑万维正式推出Matrix-Zero世界模型，成为中国第一家同时推出3D场景生成和可交互视频生成模型的探索空间智能的企业。Matrix-Zero世界模型包含两款子模型：（1）昆仑万维自研3D场景生成大模型，支持将用户输入的图片转化为可自由探索的真实合理的3D场景，比WorldLabs生成场景的探索范围更大更自由，而且包括动态物理效果；（2）昆仑万维自研可交互视频生成大模型，提供以用户
以AI之名，激发未来创想 | 微软 AI 开发者挑战赛即将启航！ microsoft
人工智能，正在重塑世界。2月5日至4月23日，加入我们，共赴一场聚焦AI技术的开发者挑战赛！在这里，创意、技术和无限可能将碰撞出耀眼火花。无论你是开发新秀还是经验丰富的技术专家，这场由微软Azure驱动的在线竞赛，将为你打开一扇通往未来的大门。为什么加入微软AI开发者挑战赛？1.赋能创想，Azure加速产品化在这里，你的创意不仅仅是想法，更是可以落地的解决方案。通过微软Azure提供的多种强大工具
2024山东省职业院校技能大赛“网络空间安全”赛题及赛题解析（超详细）_2024年山东省职业院校技能大赛中职组网络安全赛项竞赛样题(2) 2401_84252820 程序员安全 web安全
如何自学黑客&网络安全黑客零基础入门学习路线&规划初级黑客1、网络安全理论知识（2天）①了解行业相关背景，前景，确定发展方向。②学习网络安全相关法律法规。③网络安全运营的概念。④等保简介、等保规定、流程和规范。（非常重要）2、渗透测试基础（一周）①渗透测试的流程、分类、标准②信息收集技术：主动/被动信息搜集、Nmap工具、GoogleHacking③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF
AI 编程工具崛起，程序员的未来是否岌岌可危？
一、AI编程工具的现状AI编程工具的出现与迅猛发展是技术进步的必然结果。这一趋势首先得益于开源社区和代码托管平台提供的丰富代码样本，它们为AI模型的学习提供了充足的素材。其次，编程语言本身的严格语法和结构化特点，使得AI能够高效、精确地理解和生成代码。再者，深度学习技术的突破，尤其是大语言模型在代码理解与生成方面的显著进展，为AI编程提供了坚实的技术基础。最后，随着软件开发需求的不断增加，传统开发
武圣破难上山之他要学习——《贪心》曼珠沙华算法学习算法
一、贪心算法原理与实例剖析贪心算法作为一种独具特色且应用广泛的策略，占据着重要地位。其核心策略在于将复杂的整体问题，拆解为一系列紧密相连的步骤。每一个步骤都选取当前状态下的最优方案，通过这样的方式步步推进，直至完成所有步骤。从本质而言，贪心算法在处理问题时，着重于当下的抉择，全力聚焦于当下时刻的最优选择，而暂且搁置对最终结果的预先考量。然而，运用贪心算法时需格外留意一个关键前提：每一步所做出的选择
过于依赖chatgpt编程会有哪些弊端？奇偶变不变 AI chatgpt 人工智能
过于依赖ChatGPT编程可能会带来以下问题：1.基础不扎实，容易“变菜”以前遇到代码还会琢磨哪里不懂、怎么改，现在直接复制粘贴，时间长了可能连基本的语法和逻辑都搞不清楚。就像考试总抄答案，真让你自己写的时候脑子一片空白。2.代码质量看运气ChatGPT生成的代码看似能用，但可能有隐藏的bug（比如安全漏洞、性能差），或者和你的实际需求不符。如果完全不检查直接运行，相当于闭着眼睛开车，翻车概率大增
写好C/C++代码，大学生必读：林锐博士的《高质量 C++/C 编程指南》晚风る C\C++c++c语言
作为一名大学生，我深知在学习编程的过程中，写出高质量的代码是多么重要。最近，我读了林锐博士的《高质量C++/C编程指南》，这本书让我受益匪浅，今天想和大家分享一下我的学习心得。目录一、初识《高质量C++/C编程指南》二、书中的精华内容（一）编程规范与代码风格（二）内存管理（三）函数设计（四）类的构造函数、析构函数与赋值函数三、我的学习与实践四、收获与感悟五、推荐与分享一、初识《高质量C++/C编程
DeepSeek：国产AI的荣耀之光晚风る AI人工智能人工智能
DeepSeek：国产AI的荣耀之光在国产AI领域，DeepSeek（深度求索）犹如一颗璀璨的新星，以其卓越的技术实力和创新精神，迅速成为行业的焦点，被誉为“国产之光”。本文将深入探讨DeepSeek的技术亮点、市场表现以及其对行业的深远影响。一、技术突破：创新与高效并存1.混合专家架构（MoE）DeepSeek-V3采用了自主研发的混合专家架构（MoE），模型参数高达6710亿，激活参数为370
客户签了一堆，还是赚不到钱？ crm
可能和你的销售团队每个月都能签下一堆新客户，听上去像是做得不错，但等到月底结算的时候，发现，虽然签单数不错，可利润却远远不如预期，甚至出现了亏损的情况。那问题到底出现在哪？文中提到的销售管理系统，已经整理成模板，即开即用：https://s.fanruan.com/xuhns一、为什么会有问题？每个月签下很多客户，然而在财务报表上却看不到预期的利润，甚至有时还会出现亏损的情况。签了客户却赚不到钱，
破解微服务疑难杂症：2025年全解决方案 zxzy_org 微服务架构云原生算法
微服务架构已经成为现代软件开发的主流选择，其优势在于能够将复杂的系统拆分为独立的服务模块，方便开发和维护。然而，在微服务的实施过程中，开发者往往会面临许多挑战，如服务间通信、数据一致性、性能优化和故障处理等问题。2025年的全解决方案主要集中在以下几个方面：首先，通过使用先进的服务网格（ServiceMesh）技术，可以显著简化服务间通信和负载均衡管理，同时增强了服务的可观测性和安全性。其次，在数
Druid密码错误重试导致数据库超慢后端
密码错误重试导致数据库超慢有同事把项目的数据库密码配错了，导致其他所有连接该数据库的项目全部连接都获取缓慢了，一个页面加载要花费十几秒。排查mysql连接发现很多connect命令的连接showfullPROCESSLIST由于连接的host全是我们服务器的ip，所以一开始想到的是服务器是不是被黑了，然后频繁的尝试破解数据库密码赶紧查了一下是哪个进程在连接数据库netstat-anp|grep33
Druid配置大全后端
配置配置缺省值说明name-配置这个属性的意义在于，如果存在多个数据源，监控时可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是："DataSource-"+System.identityHashCode(this).另外配置此属性至少在1.0.5版本中是不起作用的，强行设置name会出错。url-连接数据库的urlusername-连接数据库的用户名password-连接数据库的密码
评测系统的神经架构搜索优化 AI天才研究院 ChatGPT 计算 DeepSeek R1 &大数据AI人工智能大模型 java python javascript kotlin golang 架构人工智能大厂程序员硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM 系统架构设计软件哲学 Agent 程序员实现财富自由
评测系统的神经架构搜索优化关键词评测系统神经架构搜索优化强化学习人工智能摘要本文将探讨评测系统的神经架构搜索优化这一主题。首先，我们将介绍评测系统的基本概念和重要性，然后深入解析神经架构搜索优化的基本原理和算法。接下来，我们将探讨神经架构搜索优化的应用场景和实战案例分析，最后进行总结和展望。第1章：引言1.1评测系统的重要性评测系统在各个领域都有着广泛的应用，如教育、工业、金融等。它的主要作用是对
Python 源码编译安装详解：跨平台指南及完整步骤解析敲代码不忘补水一起学 Python python 开发语言编译安装
Python源码编译安装详解：跨平台指南及完整步骤解析文章目录Python源码编译安装详解：跨平台指南及完整步骤解析一准备工作1）Ubuntu/Debian2）CentOS/RHEL3）macOS二下载Python源码三编译与安装1）解压源码2）配置安装选项3）编译源码4）安装四验证安装本文详细介绍了如何在不同操作系统（Ubuntu/Debian、CentOS/RHEL、macOS）上，从源码编译
Docker安装分布式vLLM MasonYyp docker 分布式容器
Docker安装分布式vLLM1介绍vLLM是一个快速且易于使用的LLM推理和服务库，适合用于生产环境。单主机部署会遇到显存不足的问题，因此需要分布式部署。分布式安装方法https://docs.vllm.ai/en/latest/serving/distributed_serving.html2安装方法⚠️注意：前期一定要把docker环境、运行时和GPU安装好。CUDAVersion：12.4
如何为中小企业选择合适的OA办公系统解决方案 oa开源
考虑云端和本地部署：对于中小企业来说，选择云端或者本地部署的OA系统都有各自的优劣势。云端OA系统通常更灵活，易于使用，并且无需大量的IT基础设施投入。而本地部署的OA系统则可能更适合对数据安全和隐私保护有较高要求的企业。择优而行：在研究市场时，中小企业可能会发现有很多OA系统提供商，但并非每一个都能满足自己的需求。建议企业可以将几个最有潜力的方案列出来，然后通过试用和评估来确定最适合自己的那个。
CRM系统定制化能力排名：满足特定业务需求的平台
在CRM的世界里，"一刀切"的解决方案往往无法满足所有企业的需求。因为每个企业都有其独特的业务模式、市场定位、客户体验要求、技术集成需求以及法规遵从性考虑。此外，企业规模、成长阶段和用户对界面的个性化需求也要求CRM系统具有高度的灵活性和定制化能力。这就是为什么CRM系统的定制化能力成为了企业在选择合作伙伴时的关键考量因素。一个高度可定制的CRM平台能够确保企业能够根据自己的特定业务需求和工作流程
CRM系统安全性排名：数据保护能力评估
安全性对CRM系统厂商和企业来说至关重要，因为它直接关系到企业的客户数据、商业机密和品牌信誉。CRM系统通常存储了大量敏感信息，包括客户联系详情、交易记录和个人身份信息，一旦发生数据泄露或安全事件，不仅可能导致客户信任丧失、法律诉讼和经济损失，还可能对企业的市场竞争力和长期发展造成严重影响。因此，CRM系统厂商必须不断加强安全措施，确保数据的保密性、完整性和可用性，而企业在选择CRM解决方案时，也
行业专家推荐：2024年CRM系统Top10 saascrm销售管理软件
2024年，是CRM系统引入中国的第25年。CRM系统已经从逐渐走向深水区。自20世纪90年代末，CRM理念开始进入中国。国内的CRM系统经历了引入期、快速成长期、本土化创新期以及智能化成熟期，哪些国内CRM系统突出重围成为客户的首选？未来CRM系统该走向哪？一、国内CRM系统发展：从引入到集成引入与初期发展阶段大约在2000年左右，随着全球经济一体化和企业竞争的加剧，CRM理念开始被中国企业所认
中小企业CRM解决方案排名：性价比之选 crm系统销售管理
中小企业在选择CRM系统时，面临的痛点主要包括预算有限而需求多样，希望以高性价比的方案满足营销、销售、服务等全方位需求；同时，由于IT资源相对匮乏，期望系统操作简便、易上手，以减少培训成本和时间；此外，还希望CRM系统能够快速适应企业快速发展的变化，具备足够的灵活性和可扩展性，以支撑企业的持续增长。在当今竞争激烈的市场环境中，中小企业如何高效地管理客户关系、提升销售业绩，成为了决定其生死存亡的关键
redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSource expire/del incr/lpush 数据库分区 redis
最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷） 1、关于JedisPool.returnSource(Jedis jeids) 这个方法是从red
SQL性能优化-持续更新中。。。。。。 atongyeye oracle sql
1 通过ROWID访问表--索引你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
[JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
lvs- real 男人50 LVS
#!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #. /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
生成公钥和私钥 oloz DSA 安全加密
package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
UIView 中加入的cocos2d，背景透明 374016526 cocos2d glClearColor
要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
mysql常用命令香水浓 mysql
连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScript jquery css html5
系统层面：高可用性所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
利用ant进行远程tomcat部署 aijuans tomcat
在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
获取复利总收入 baalwolf 获取
public static void main(String args[]){ int money=200; int year=1; double rate=0.1; &
eclipse.ini解释 BigBird2012 eclipse
大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
AngularJS实现分页功能 bijian1013 JavaScript AngularJS 分页
对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。 &nbs
[Maven学习笔记三]Maven archetype bit1129 ArcheType
archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等. mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式， mvn archetype 1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
【Java命令三】jps bit1129 Java命令
jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看 [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学 unity教程 unity视频 unity资料 unity
unity 3d还是cocos2dx哪个适合游戏？问：unity 3d还是cocos2dx哪个适合游戏？答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java 算法面试百度招聘
import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
获取checkbox复选框的值 chiangfai checkbox
<title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
MySQLdb用户指南 chenchao051 mysqldb
原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
HIVE 窗口及分析函数 daizj hive 窗口函数分析函数
窗口函数应用场景：（1）用于分区排序（2）动态Group By （3）Top N （4）累计计算（5）层次查询一、分析函数用于等级、百分点、n分片等。函数说明 RANK() &nbs
PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHP zip
PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
精彩英语贺词 dcj3sjt126com 英语
I'm always here 我会一直在这里支持你 &nb
基于Java注解的Spring的IoC功能 e200702084 java spring bean IOC Office
java模拟post请求 geeksun java
一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
Swift语法之 ---- ?和!区别 hongtoushizi ?swift !
转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
centos7安装jdk1.7 jisonami jdk centos
安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
数据源架构模式之数据映射器 home198979 PHP 架构数据映射器 datamapper
前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。一、概念数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
在Python中使用MYSQL pda158 mysql python
缘由　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到数据库中。　　了解到 Python在这方面有优势，便选用之。　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里记录一下，大家共勉。　　 python中mysql的调用　　百度之后能够通过MySQLdb进行数据库操作。
单例模式 hxl1988_0311 java 单例设计模式单件
package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。

C++的JSON库及使用方法

你可能感兴趣的:(C++的JSON库及使用方法)