C++ 指针 new delete

///C++指针：
///  *操作符两边的空格是可选的。传统的，C程序员使用这种格式：int *ptr;这强调
///  *ptr是一个int型的值，而C++程序员一般用这种格式：int* ptr;这强调的是：int*
///  是一种类型，是指向int的指针
///  int* p1,p2;将创建一个指针p1,和一个整型的p2。对于每个指针变量名，都需要使
///  用一个*
///  在C++中，int* 是一种复合类型，是指向int的指针
///  指针的危险： long * fellow;    *fellow = 223323;   fellow的确是一个指针，但
///  上述代码并未将地址赋给fellow，所以fellow指向的地方很可能不是所要存储
///  223323的地方，这种错误可能导致一些最隐匿的bug
///  *************一定要在对指针应用解除引用操作符（*）之前，将指针初始化为一个
///  确定的，适当的地址。这是关于使用指针的金科玉律。
///  不能简单地将整数赋给指针：
///  int * pt;   pt = 0xB8000000;///type not match
///  要将数字作为地址来使用，应通过强制类型转换将数字转换为适当的地址类型：
///  int * pt;
///  pt = (int *) 0xB8000000;///types now match
///  pt 是int值的地址，并不意味着pt本身的类型是int
///  使用new来分配内存：
///  int * pn = new int;
///  new int 告诉程序，需要适合存储int的内存，new操作符根据类型来确定需要多少字节的
///  内存，然后，他找到这样的内存，并返回该内存块的地址。接下来，将地址赋给pn
///  pn是被声明为指向int的指针。现在，pn是地址，而*pn是存储在那里的值，将这种
///  方法与将变量的地址赋给指针进行比较：
///  int higgens;
///  int * pt = &higgens;
///  在这两种情况下：都是将一个int变量的地址赋给指针，在第二种情况下，可以通过
///  名称higgens来访问该int,在第一种情况下，则只能通过该指针进行访问。而pn指向
///  内存没有名称，pn指向一个数据对象，这里的对象不是面向对象编程中的对象。
///  而是一样东西，术语数据对象比变量更通用，它指的是为数据项分配的内存块，因
///  此,变量也是数据对象，但pn指向的内存不是变量，处理数据对象的指针使程序在
///  管理内存方面有更大的控制权。
///  为一个数据对象（可以是结构，也可以是基本类型）获得并指定分配内存的通用
///  格式如下：typeName pointer_name = new typeName;
///  需要在两个地方指定数据类型，用来指定需要什么样的内存和用来声明合适的指针
///  use_new.cpp -- using the new operater
/*
#include<iostream>
using namespace std;
int main()
{
    int * pt = new int;
    *pt = 1001;
    cout << "int ";
    cout << "value = " << *pt << ": location = " << pt << endl;

    double * pd = new double;
    *pd = 1000001.0;

    cout << "double ";
    cout << "value = " << *pd << ": location = " << pd << endl;
    cout << "size of pt = " << sizeof(pt);
    cout << ": size of *pt = " << sizeof(*pt) << endl;
    cout << "size of pd = " << sizeof pd;
    cout << ": size of *pd = " << sizeof (*pd) << endl;
    return 0;
}
int value = 1001: location = 0x5d2a38
double value = 1e+006: location = 0x5d2a48
size of pt = 4: size of *pt = 4
size of pd = 4: size of *pd = 8

Process returned 0 (0x0)   execution time : 0.645 s
Press any key to continue.
*/
///指向int和指向double的指针相同，它们都是地址。
///计算机可能会由于没有足够的内存而无法满足new的要求。此情况下，new将返回0.
///C++中，值为0的指针被称为空值指针。C++确保空值指针不会指向有效的数据，因此
///它常被用来表示操作符或函数失效，若成功，他们将返回一个有用的指针，可以通
///过if语句检查new是否返回的是空指针，从而防止程序超界。若无法分配内存，new
///除返回空值指针外，还可能引发bad_alloc异常。
///使用delete来释放内存:
///当需要内存时，可以使用new来请求，这只是C++内存管理数据包中有魅力的一个方
///面,另一个方面是delete操作符，它使得在使用完内存后，能够将其归还给内存池，
///这是通向最有效的使用内存的关键一步，归还或释放的内存可供程序的其他部分使
///用,使用delete时，后面要加上使用内存块的指针（这些内存块最初由new分配），
///int * ps = new int;
///...
//;;;;;;/delete ps;
///这将
///释放ps指向的内存，但不会删除指针ps本身。还可以将ps重新指向另一个新分
///配的内存块，一定 要配对的使用new和delete,否则将发生内存泄漏，也就是说，被
///分配的内存在也无法使用了。若内存泄漏严重，则程序将由于不断寻找更多内存而
///终止.
///不要尝试释放已经释放的内存块，C++标准指出，这样做的结果是不确定的，这意味
///不能使用delete来释放声明变量所获得的内存,
 /*
 int * ps = new int;///ok
 delete ps;///ok
 delete ps;///not ok now
 int jug = 5;///ok
 int * pi = &jugs;///ok

 delete pi;///not allowed,memory not allocated（分配） by new
 */
///只能用delete来释放使用new分配的内存。不过，对空指针使用delete是安全的
///使用delete的关键在于将它用于new分配的内存。这并不意味著要使用用于new的指针
///而是用于new的地址
/*
int * ps = new int;///allocated memory
int * pq = ps;///set second pointer to same block
delete pq;///delete with second pointer_safety
*/
///一般来说，不要创建两个指向同一个内存块的指针，因为这将增加错误地删除同一个
///内存块两次的可能性，但是，对于返回指针的函数，使用另一个指针确实有道理
///****************************************************************************

///new的用武之地是大型数据，
///使用new来创建动态数组
/*
int * psome = new int [10];///get a block of 10 ints
*/
///new操作符返回第一个元素的地址，此例子中，该地址被赋给指针psome.当程序结束
///使用内存块时，应使用delete释放它们
///使用new创建数组时，应使用另一种格式的delete，它指出所要释放的是一个数组
/*
delete [] psome;///free a dynamic array
*/
///方括号告诉程序，应释放整个数组，而不仅仅是指针指向的元素，new与delete的
///格式一定要匹配，即使用new时不带方括号，使用delete时也不应带方括号，若使用
///new时带方括号，则使用delete时也应带方括号
///使用new和delete应遵守以下规则：
/*
*不要使用delete来释放不是new分配的内存
*不要使用delete释放同一个内存块两次
*若使用new[]为数组分配内存，则应用delete[]来释放
*若使用new为一个实体分配内存，则应该使用delete（没有方括号）来释放
*对空值指针应用delete是安全的
*/
///不能使用sizeof操作符来确定动态分配的数组包含的字节数
///为数组分配内存的通用格式如下：
/*
type_name pointer_name = new type_name [num_elements];
*/
///使用new操作符可以确保内存块足以存储num_elements个类型为type_name的元素
///而pointer_name将指向第1个元素，能以使用数组名的方式来使用pointer_name
#include<iostream>

using namespace std;

int main()
{
    double * p3 = new double [3];///space for 3 doubles
    p3[0] = 0.2;///treat p3 as an array name
    p3[1] = 0.5;
    p3[2] = 0.8;
    cout << "p3[1] is " << p3[1] << ".\n";
    p3 = p3 + 1;///increment the pointer,okay for pointers,wrong for array names
    cout << "Now p3[0] is " << p3[0] << " and ";
    cout << "p3[1] is " << p3[1] << ".\n";
    p3 = p3 - 1;///point back to beginning
    delete [] p3;///free the memory
    return 0;
}
p3[1] is 0.5.
Now p3[0] is 0.5 and p3[1] is 0.8.

Process returned 0 (0x0)   execution time : 0.359 s
Press any key to continue.
///不能修改数组名的值，由于指针是变量，所以可以修改指针的值。p3 = p3 - 1,
///指针复位，给delete[]提供正确的地址

/*矩阵专职中应用到的几种不同的动态内存分配方法 第一种不是
#include <iostream>

using namespace std;

int a[4][4];
int b[4][4];

int main()
{
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cin >> a[i][j];
            b[j][i] = a[i][j];
        }
    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cout << b[i][j] << ' ';
        }
        cout << endl;
    }
    return 0;
}
*/
#include <iostream>

using namespace std;

int main()
{
    int **a;
    int **b;
    a = new int *[3];
    b = new int *[3];
    for(int i=0; i<3; i++)
        a[i] = new int[3];
    for(int i=0; i<3; i++)
        b[i] = new int[3];
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cin >> a[i][j];
            b[j][i] = a[i][j];
        }
    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cout << b[i][j] << ' ';
        }
        cout << endl;
    }
    return 0;
}
///********************************************
/*
#include<iostream>
using namespace std;

int main()
{
    int *a;
    a = new int[3*3];/// int a[9];
    int *b;
    b = new int[3*3];///int b[9];


    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cin >> a[i*3+j];
            b[j*3+i] = a[i*3+j];
        }
    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cout << b[i*3+j] << ' ';
        }
        cout << endl;
    }
}
*/
///*****************************************vector
/*
#include<iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int>a(3*3);
    vector<int>b(3*3);
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cin >> a[i*3+j];
            b[j*3+i] = a[i*3+j];
        }
    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            cout << b[i*3+j] << ' ';
        }
        cout << endl;
    }
}
*/