c++之内存分配、命名空间、强制类型转换学习总结

变量申请格式：


Type* pointer = new Type;

//

delete pointer

数组申请格式：


Type *pointer = new Type[N];

//

delete [] pointer;
  

#include <stdio.h>

int main()
{
    int *p = new int;
    *p=5;
    *p=*p+10;

    printf("p= %p\n",p);
    printf("*p=%d\n",*p);

    delete p;

    p = new int[10];

    for(int i=0;i<10;i++)
    {
       p[i]=i+1;
       printf("p[%d] = %d\n",i,p[i]);
    }

    delete [] p;

    return 0;

}

p= 0xb6d010
*p=15
p[0] = 1
p[1] = 2
p[2] = 3
p[3] = 4
p[4] = 5
p[5] = 6
p[6] = 7
p[7] = 8
p[8] = 9
p[9] = 10

1、new关键字是C++的一部分。

2、malloc是由c库函数提供的。

3、new关键字以具体类型为单位进行内存分配。

4、malloc函数是以字节为单位进行内存分配。

5、new关键在申请单个类型变量时可以进行初始化。

6、malloc 不可以进行内存初始化。

#include <stdio.h>
int main()
{
    int * pi = new int(1);
    float *pf = new float(2.0f);
    char *pc = new char('c');

    printf("*pi=%d\n",*pi);
    printf("*pf=%f\n",*pf);
    printf("*pc=%c\n",*pc);

    delete pi;
    delete pf;
    delete pc;

   return 0;


}

*pi=1
*pf=2.000000
*pc=c

namespace Name 
{
     namespace Internal
     {
     
     
     
     }
}

#include <stdio.h>

namespace First
{
     int i =0;

}

namespace Second
{

   int i =1;
   namespace Internal
  {

     struct Test
     {
         int x;
         int y;

     };

  }

}
int main()
{
   using namespace First;
   using Second::Internal::Test;

   printf("First::i is %d\n",i);
   printf("Second::i is %d\n",Second::i);

  Test i={2,4};

  printf("i.x is %d\n",i.x);
  printf("i.y is %d\n",i.y);

  return 0;



}

First::i is 0
Second::i is 1
i.x is 2
i.y is 4

#include <stdio.h>

void static_cast_demo()
{
    int i =55;
    char c ='c';
    int *pi =&i;
    char *pc =&pc;

    c=static_cast<char>(i);
    pc=static_cast<char*>(pi);

}
int main()
{
    static_cast_demo();

    return 0;

}

t.cpp: In function ‘void static_cast_demo()’:
t.cpp:8:16: error: cannot convert ‘char**’ to ‘char*’ in initialization
     char *pc =&pc;
                ^
t.cpp:11:29: error: invalid static_cast from type ‘int*’ to type ‘char*’
     pc=static_cast<char*>(pi);
                             ^

#include <stdio.h>

void const_cast_demo()
{
    const int& j =2;
    int& k = const_cast<int&>(j);

    const int x = 4;
    int& y = const_cast<int&>(x);

    int z = const_cast<int>(x);

    k=8;

   printf("k=%d\n",k);
   printf("j=%d\n",j);

   j =12;

   printf("x=%d\n",x);
   printf("y=%d\n",y);
   printf("&x=%p\n",&x);
}
int main()
{
    const_cast_demo();

    return 0;

}

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;

#include <stdio.h>
void reinterpret_cast_demo()
{
    int i =2;
    char c = 'c';
    int *pi = &i;
    char *pc =&c;

    pc=reinterpret_cast<char*>(pi);
    pi=reinterpret_cast<int*>(pc);
    pi=reinterpret_cast<int*>(i);
    c=reinterpret_cast<char(i);


}

int main()
{
    reinterpret_cast_demo();

    return 0;

}

t.cpp: In function ‘void reinterpret_cast_demo()’:
t.cpp:12:28: error: expected ‘>’ before ‘(’ token
     c=reinterpret_cast<char(i);
                            ^
t.cpp:12:30: error: invalid cast from type ‘int’ to type ‘char’
     c=reinterpret_cast<char(i);

#include <stdio.h>
void dynamic_cast_demo()
{
      int i =2;
      int *pi=&i;
      char *pc =dynamic_cast<char*>(pi);

}

int main()
{
    dynamic_cast_demo();

    return 0;

}

.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)
       char *pc =dynamic_cast<char*>(pi);