一、C++动态内存分配：

在学习c语言的时候，我们一般都是使用库函数malloc（）来进行内存的申请分配，然后使用库函数free()来进行释放申请到的内存；现在在c++里面采用了另外一种内存申请的方法：

• c++中通过new关键字进行动态内存申请。
• C++中的动态内存申请是基于类型进行的。
• delete关键字用于内存释放。
  
  

下面是申请内存的类型：

变量申请格式：


, I4 i* f, B! u& g/ FType* pointer = new Type;

//

. N0 M3 k3 O; pdelete pointer

3 r) W8 n  r  v0 ~" I9 C6 w" {
1 o! R7 E( y2 x  K9 v' j
数组申请格式：
4 @" C8 |* B$ P- I

- x' d( S6 s9 sType *pointer = new Type[N];
- T. W+ L3 w1 B5 f( w6 a
0 a8 `/ ~" q$ q1 y- C& B//
0 E8 S8 Q& ~* L
delete [] pointer;
  
: J0 ?5 w1 U/ i: l5 z; d

下面我们来看一个例子：

#include <stdio.h>

9 K2 V( \; u6 ?5 T) f( bint main()
{
' t: M( k9 ?5 ?0 r5 H* h    int *p = new int;
; w" [8 ^" h$ b' E    *p=5;
    *p=*p+10;

    printf("p= %p\n",p);
) V) k0 l# @/ r* o8 b# ~1 \5 Q    printf("*p=%d\n",*p);

    delete p;

    p = new int[10];
6 s$ _  M; q1 v; I6 R5 x
% f. P7 P7 D8 L: {    for(int i=0;i<10;i++)
2 Y, ^; L0 L- J4 X+ W    {
       p=i+1;
& H# @: `" _* O8 x6 e/ f       printf("p[%d] = %d\n",i,p);
    }
1 x8 n7 E0 i) z4 Y7 ?- r2 T" B
, a3 `/ }  {9 C6 J$ s9 x' g    delete [] p;

  R! C) h, n' X    return 0;
6 c( f0 m$ R, o% y* v- B
" \  _% v5 a' i* O}

输出结果：

p= 0xb6d010
/ N9 T: o: U; K) ?6 U*p=15
7 J" j0 u0 T) E* Bp[0] = 1
p[1] = 2
p[2] = 3
p[3] = 4
p[4] = 5
p[5] = 6
3 i) ]( `; |! ~7 ]: wp[6] = 7
8 j' q  D: n) Zp[7] = 8
p[8] = 9
# i  |0 J" ?! g: K, _p[9] = 10

二、new关键字与malloc函数的区别：

1、new关键字是C++的一部分。
0 {# K, x* [: C
1 P9 }8 q6 l; H0 r$ y2、malloc是由c库函数提供的。
: j- ~7 f% j2 m: A+ l  w9 J
3、new关键字以具体类型为单位进行内存分配。

4、malloc函数是以字节为单位进行内存分配。
. @" }: ]2 K' x: A7 G; A# E
9 Y' ~$ t; \. s1 d# p5、new关键在申请单个类型变量时可以进行初始化。
& f% [! `! c9 m) G
1 l; Q$ W9 B! Q( L* P# G" d8 i6、malloc 不可以进行内存初始化。

" E& v" N7 _" t6 @, s

我们来看使用new关键字是如何进行初始化的：

#include <stdio.h>
int main()
{
5 s( D. I2 E+ n# Y0 |9 ]( E6 H    int * pi = new int(1);
5 x2 {, O/ }4 j$ A  b    float *pf = new float(2.0f);
4 s; {) q- F- M" {5 {    char *pc = new char('c');
% a& E  _6 \# k: {7 T
    printf("*pi=%d\n",*pi);
    printf("*pf=%f\n",*pf);
( q0 _2 a5 G) v3 ]8 n% t+ u9 e/ X9 O    printf("*pc=%c\n",*pc);
( ?* `- \7 q' o; _( ~6 W$ _# V
    delete pi;
( c' N! \0 l9 K  O    delete pf;
    delete pc;
- c5 n/ P1 z9 U+ Y6 C- n; i6 t
4 H  [% q% z1 ~   return 0;


}
  |: V6 B) F4 Q

输出结果:

*pi=1
*pf=2.000000
*pc=c
/ M$ b# G; I( b+ a$ b5 }5 b
+ o8 j& H& [: K' k$ V

三、c++ 中的命名空间：

在c语言中只有一个全局作用域：

• c语言中所有的全局标识符共享同一个作用域。
• 标识符之间可能会发生冲突。-
  
  

c++中提出了命名空间的概念：

• 命名空间将全局作用域分成不同的部分。
• 不同命名空间中的标识符可以同名而且不会发生冲突。
• 命名空间可以相互嵌套。
• 全局作用域也叫默认命名空间。
  
  9 J% u& w' o2 W% O, I/ D" |) ^

1、下面我们来看一下c++中命名空间的定义：

namespace Name
{
1 ?3 r/ T: A, K/ D4 K7 H     namespace Internal
4 M; j! \$ k' T+ y# o     {
! A& [4 H) Y. s7 |! b     
8 p+ c- a# O& N7 A* n     
0 v5 g2 @. a1 D3 p8 U% w     
     }
}

2、c++命名空间的使用：

• 使用整个命名空间：using namespace name;
• 使用命名空间中的变量：using name::variable;
• 使用默认命名空间中的变量：::variable;
  
  

3、代码示例：

#include <stdio.h>
) |8 S5 Q3 E) W$ m, k5 H! A
namespace First
{
1 a9 p6 m* ]2 ~; j: U     int i =0;

3 k* m" A5 w. j6 d+ M$ z}

namespace Second
{

4 m& c' v5 o, X; s% {   int i =1;
' E. W3 P( M. w/ N) N, t   namespace Internal
  {

     struct Test
     {
5 z  a, q8 S$ o* ~3 F7 \$ U         int x;
         int y;
+ X+ X+ }$ o8 I& R9 W3 ~
! E8 x- M9 v5 ]! g6 A% a5 t/ z     };

  }
/ L: l# p2 M- ?1 q. h4 J9 }
}
' N+ v! k* _5 Cint main()
0 l4 K6 h6 X* N8 V, g" e( w8 a{
. W: n( w) v! {* K% P   using namespace First;
# [# Z1 ]5 J9 M- B& [2 k" o   using Second::Internal::Test;
- }1 B' t# Y3 X/ W9 K8 G
   printf("First::i is %d\n",i);
) C9 W; v, d5 c; d' i& ]   printf("Second::i is %d\n",Second::i);
) _5 ]! b7 u" f) w& |6 r
& ]1 F9 g( F' V2 l  Test i={2,4};

  printf("i.x is %d\n",i.x);
8 B( Z. t6 g7 M  printf("i.y is %d\n",i.y);

- \  }, J8 G: k  D, P& g  return 0;
& J* G, Y8 L2 D) a& i. }
( B2 J' W6 `. ]- {' E4 E0 x- r
$ Y3 ~* ?' a, A2 B7 c* E' ], A7 d6 Y
" f: S+ `" y2 X& ?7 A: a}

输出结果：

First::i is 0
Second::i is 1
$ K  E% f& U4 S' ~8 Si.x is 2
( Q- q: l) a0 r# i! c; C, li.y is 4

* D8 r! x/ q: }" L6 k* S) _4 a

四、c++中的四种强制类型转换

强制类型转换类型汇总

) ^% U5 t! E! }' }static_castconst_cast
dynamic_castreinterpret_cast

用法：xxx_cast(Expression)

下面是每种强制类型的具体讲解：

1、static_cast强制类型转换：

• 用于基本类型之间的转换
• 不能用于基本类型指针之间的转换
• 用于有继承关系类对象之间的转换和类指针之间的的转换
  
  

代码解析：

#include <stdio.h>

void static_cast_demo()
{
3 f+ }2 j7 |0 V: I# u1 r4 l    int i =55;
    char c ='c';
7 U3 {; n/ G5 Q. z, ?    int *pi =&i;
    char *pc =&pc;

    c=static_cast<char>(i);
    pc=static_cast<char*>(pi);
6 e1 F$ u5 [" Y" l4 ]( g/ H
}
9 I8 b6 k$ |% s4 G. yint main()
/ n' Z5 O3 @; P% j# a{
    static_cast_demo();

    return 0;
. l" H; e) R. }
: F, x" ]/ u& Y, _6 H$ S. L' d}

6 d& u5 j' }( }; j1 F1 H/ A

输出结果：

t.cpp: In function ‘void static_cast_demo()’:
2 ~7 C) e+ \& B  X8 c/ M2 Ot.cpp:8:16: error: cannot convert ‘char**’ to ‘char*’ in initialization
     char *pc =&pc;
0 W/ l" Q" t/ `4 H! d( \$ {. D                ^
* ?; I; X5 `; {5 {2 Bt.cpp:11:29: error: invalid static_cast from type ‘int*’ to type ‘char*’
     pc=static_cast<char*>(pi);
  ?" l' B+ L0 ^+ p) o5 Z: P                             ^

& Q. }, Z- Z& c1 X5 W4 C

刚好验证了我们上面说的static_cast不能用在基本类型指针之间进行强制转换。

2、const_cast强制类型转换：

• 用于去除变量的只读属性
• 强制类型转换的目标类型必须是指针或者引用
  
  

代码解析：

#include <stdio.h>
5 y8 H2 Z7 w8 b% j: s1 q, C! ^
void const_cast_demo()
{
    const int& j =2;
0 ]8 Q' q) a, G3 f; M5 z    int& k = const_cast<int&>(j);

0 _, ~, F! R6 u    const int x = 4;
- X% `9 x9 i- m4 p2 y3 x    int& y = const_cast<int&>(x);
' F' K! t* b% E0 T$ D
    int z = const_cast<int>(x);

    k=8;
0 ~3 O8 [+ O, Z: Y& M
' n& C  ^9 _3 ]  J5 w   printf("k=%d\n",k);
2 t* s* E  ?7 H- B   printf("j=%d\n",j);

   j =12;
+ F9 V0 l' W% K& u' G2 }: W
3 s. ^) H8 i; z# d   printf("x=%d\n",x);
* u  C4 P. N" n, u7 t7 H   printf("y=%d\n",y);
   printf("&x=%p\n",&x);
}
int main()
{
! e' w, J0 P$ x7 ^0 x+ N    const_cast_demo();
6 M0 n$ y0 ]4 f0 A. ]5 E
( |6 Q- f! V5 d4 E( q    return 0;
1 d7 j# ~; ~" @: Y, h+ t( T+ Z1 g
}

输出结果：

t.cpp: In function ‘void const_cast_demo()’:
t.cpp:11:30: error: invalid use of const_cast with type ‘int’, which is not a pointer, reference, nor a pointer-to-data-member type
     int z = const_cast<int>(x);
                              ^
t.cpp:18:6: error: assignment of read-only reference ‘j’
    j =12;
: {2 U2 x  f/ z. g0 E+ w& D
! W- o' g+ W2 i, D- Q9 v

通过上面的z转换，我们可以发现它的目标不是指针或者引用，所以报错。

3、reinterpret_cast强制类型转换：

• 用于指针类型之间的强制转换
• 用于整数和指针类型之间的强制转换
  
  6 E8 o! G3 i* B2 O: E& i

代码解析：

#include <stdio.h>
void reinterpret_cast_demo()
- I  N* n( Q2 }- |" {5 \, U2 y! t{
    int i =2;
    char c = 'c';
  v0 J' f6 W- ?: Y# I0 X$ y    int *pi = &i;
    char *pc =&c;

& U( ~1 Z( ?' b9 v$ ]6 n( u    pc=reinterpret_cast<char*>(pi);
    pi=reinterpret_cast<int*>(pc);
    pi=reinterpret_cast<int*>(i);
3 g( J) v, h& ?/ a! |    c=reinterpret_cast<char(i);
; ?+ V; k1 u. H+ w% O' w/ {
0 P# V  a: n+ u* D! R" p
}
# L; u1 Z; J: H5 K2 a! o* E
2 x7 U6 ?- V6 U5 z6 sint main()
{
7 X- H, A9 a1 i- W. l7 p2 k    reinterpret_cast_demo();

    return 0;
: z  j; s1 K9 a9 d
}

! J% Y9 {, k. G3 [" A( R1 V

输出结果：

t.cpp: In function ‘void reinterpret_cast_demo()’:
6 e& [1 N- o# P1 Yt.cpp:12:28: error: expected ‘>’ before ‘(’ token
( P7 f8 U4 s* L3 x9 ]  F     c=reinterpret_cast<char(i);
                            ^
t.cpp:12:30: error: invalid cast from type ‘int’ to type ‘char’
     c=reinterpret_cast<char(i);

: n  u9 i- v, i1 G) O

从结果我们可以看到，它用于整数之间的转换，不符合规则，所以报错。

4、dynamic_cast强制类型转换（暂时有些概念没有学到，先记住结论）：

• 用于有继承关系的类指针之间的转换
• 用于有交叉关系的类指针之间的转换
• 具有类型检查的功能
• 需要虚函数的支持
  
  " e4 q% o' C8 H7 l' B0 W9 W! |% U

代码分析：

#include <stdio.h>
& p/ Q! W2 W7 \, Ivoid dynamic_cast_demo()
- `* m8 |* [: H! l6 E{
      int i =2;
3 p* M+ \* x' S5 d1 V4 k8 P      int *pi=&i;
, z; T! H1 u; F' f( |      char *pc =dynamic_cast<char*>(pi);

}
% ~" a7 }. Y" U
int main()
{
    dynamic_cast_demo();
3 Y, A4 t4 x" ]0 C3 W
3 t/ \$ a7 `8 n( e    return 0;
, W$ o9 Z9 m" [* _
}
- c! P8 i: |* ?) a6 f8 z6 P
2 a8 z; H, T, e8 a

输出结果：

.cpp: In function ‘void dynamic_cast_demo()’:
t.cpp:6:39: error: cannot dynamic_cast ‘pi’ (of type ‘int*’) to type ‘char*’ (target is not pointer or reference to class)
1 ?7 \+ [/ f- I. G* F$ v2 L       char *pc =dynamic_cast<char*>(pi);
! S9 }! m( g  {* }- h3 c/ ~6 Y( ~
3 Y+ s7 U2 ^2 T2 l. F7 U8 R

不符合规则，所以报错。

5、小结：

上面四种类型转换的例子，前三种把错误的地方给屏蔽掉，就是正确的例子，第四种类型转换，暂时继承的概念没有学到，所以这个例子不是很好。

同时内存分配的使用，本次也只是简单的说了一下概念，在真正实操当中，还是有很多要注意的地方，下期文章我们再详细解析。

顶一下