一些有用的c++ utility

最新推荐文章于 2025-04-30 09:20:17 发布

最新推荐文章于 2025-04-30 09:20:17 发布 · 171 阅读

文章标签：

本文介绍了一些C++编程中实用的技巧，包括数组元素计数宏定义、类型安全的数组操作、字符串处理函数、以及十六进制转储函数等。这些技巧能够帮助开发者更高效地进行C++编程。

一些有用的c++ utility

#define ITEMSOF(arr)    (sizeof(arr) / sizeof(0[arr]))

(0[arr] is identical to arr[0] for arrays but will intentionally fail if it's used against a C++ object that overloads operator[] .)

The C++ version is less intuitive but more type-safe:

template<int n>
struct char_array_wrapper{
    char result[n];
};

template<typename T, int s>
char_array_wrapper<s> the_type_of_the_variable_is_not_an_array(const T (&array)[s]){
}

#define ITEMSOF(v) sizeof(the_type_of_the_variable_is_not_an_array(v).result)

#ifdef
 NDEBUG

#define
 
Dprintf
(
format
,
 
...)


#else


#define
 
Dprintf
(
format
,
 
...)
 
/


  fprintf
(
stderr
,
 
"[%s]:%s:%d: "
 format
,
 __FILE__
,
 
/


    __func__
,
 __LINE__
,
 
##__VA_ARGS__)


#endif

class
 make_string

{


public
:


template
 
<
typename
 T
>


 make_string
&
 
operator
<<(
 T 
const
 
&
 datum 
)


{


   buffer_ 
<<
 datum
;


return
 
*
this
;


}


operator
 std
::
string 
()
 
const


{


return
 buffer_
.
str
();


}


private
:


 std
::
ostringstream buffer_
;


};



// usage:


void
 f
(
 std
::
string 
const
 
&
 
);


int
 main
()


{


 std
::
string name 
=
 
"David"
;


 f
(
 make_string
()
 
<<
 
"Hello "
 
<<
 name 
<<
 
"!"
 
);


}

class
 make_string

{


// ...


public
:


operator
 
const
 
char
*
 
()
 

{


return
 buffer_
.
str
().
c_str
();


}


};

inline std::string &rtrim(std::string &s) {

 s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int,

int>(std::isspace))).base(), s.end());

 return s;

}


inline std::string &ltrim(std::string &s) {

 s.erase(s.begin(), std::find_if(s.begin(), s.end(),

std::not1(std::ptr_fun<int, int>(std::isspace))));

 return s;

}


inline std::string &trim(std::string &s) {

 return ltrim(rtrim(s));

}

template
 
<
class
 C
>


class
 _StringBuffer

{


typename
 std
::
basic_string
<
C
>
 
&
m_str
;


typename
 std
::
vector
<
C
>
 m_buffer
;



public
:


  _StringBuffer
(
std
::
basic_string
<
C
>
 
&
str
,
 size_t nSize
)


:
 m_str
(
str
),
 m_buffer
(
nSize 
+
 
1
)
 
{
 get
()[
nSize
]
 
=
 
(
C
)
0
;
 
}



~
_StringBuffer
()


{
 commit
();
 
}



  C 
*
get
()


{
 
return
 
&(
m_buffer
[
0
]);
 
}



operator
 C 
*()


{
 
return
 get
();
 
}



void
 commit
()


{


if
 
(
m_buffer
.
size
()
 
!=
 
0
)


{


      size_t l 
=
 std
::
char_traits
<
C
>::
length
(
get
());



      m_str
.
assign
(
get
(),
 l
);



      m_buffer
.
resize
(
0
);


}


}



void
 abort
()


{
 m_buffer
.
resize
(
0
);
 
}


};



template
 
<
class
 C
>


inline
 _StringBuffer
<
C
>
 
StringBuffer
(
typename
 std
::
basic_string
<
C
>
 
&
str
,
 size_t nSize
)


{
 
return
 _StringBuffer
<
C
>(
str
,
 nSize
);
 
}

So now I can say:

std
::
string str
;


GetWindowsDirectory
(
StringBuffer
(
str
,
 MAX_PATH
),
 MAX_PATH
);

A simple hexdump is often good to have...

#include
 
<ctype.h>


#include
 
<stdio.h>



void
 hexdump
(
void
 
*
ptr
,
 
int
 buflen
)
 
{


unsigned
 
char
 
*
buf 
=
 
(
unsigned
 
char
*)
ptr
;


int
 i
,
 j
;


for
 
(
i
=
0
;
 i
<
buflen
;
 i
+=
16
)
 
{


  printf
(
"%06x: "
,
 i
);


for
 
(
j
=
0
;
 j
<
16
;
 j
++)
 

if
 
(
i
+
j 
<
 buflen
)


    printf
(
"%02x "
,
 buf
[
i
+
j
]);


else


    printf
(
"  "
);


  printf
(
" "
);


for
 
(
j
=
0
;
 j
<
16
;
 j
++)
 

if
 
(
i
+
j 
<
 buflen
)


    printf
(
"%c"
,
 isprint
(
buf
[
i
+
j
])
 
?
 buf
[
i
+
j
]
 
:
 
'.'
);


  printf
(
"/n"
);


}


}