C++学习笔记——003

• malloc() 函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。

//一维数组动态分配，数组长度为 m
int *array = new int [m];
 
//释放内存
delete [] array;


//二维数组
int **array;


// 假定数组第一维长度为 m， 第二维长度为 n
// 动态分配空间
array = new int *[m];
for(int i = 0; i < m; ++i)
{
    array[i] = new int [n];
}


//释放
for(int i = 0; i < m; ++i)
{
    delete [] array[i];
}
delete [] array;

• new 和 malloc 内部的实现方式有什么区别？new 的功能是在堆区新建一个对象，并返回该对象的指针。所谓的“新建对象”的意思就是，将调用该类的构造函数，因为如果不构造的话，就不能称之为一个对象。而 malloc 只是机械的分配一块内存，如果用 malloc 在堆区创建一个对象的话，是不会调用构造函数的。严格说来用 malloc 不能算是新建了一个对象，只能说是分配了一块与该类对象匹配的内存而已，然后强行把它解释为“这是一个对象”。同样的，用 delete 去释放一个堆区的对象，会调用该对象的析构函数。用 free 去释放一个堆区的对象，不会调用该对象的析构函数。做个简单的实验即可明了:

#include <iostream>
#include <malloc.h>


class TEST
{
private:
    int num1;
    int num2;
    
public:
    TEST()
    {
        num1 = 10;
        num2 = 20;
    }
    void Print()
    {
        std::cout << num1 << " " << num2 << std::endl;
    }
};


int main(void)
{
    // 用malloc()函数在堆区分配一块内存空间，然后用强制类型转换将该块内存空间
    // 解释为是一个TEST类对象，这不会调用TEST的默认构造函数
    TEST * pObj1 = (TEST *)malloc(sizeof(TEST));
    pObj1->Print();


    // 用new在堆区创建一个TEST类的对象，这会调用TEST类的默认构造函数
    TEST * pObj2 = new TEST;
    pObj2->Print();


    return 0;
}


/*
运行结果：


-----------------------------
-842150451 -842150451       |
10 20                       |
请按任意键继续. . .         |
-----------------------------
我们可以看到pObj1所指的对象中，字段num1与num2都是垃圾值
而pObj2所指的对象中，字段num1与num2显然是经过了构造后的值
*/

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。

• 静态转换（Static Cast）：静态转换是将一种数据类型的值强制转换为另一种数据类型的值。静态转换通常用于类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。

int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型

• 动态转换（Dynamic Cast）：动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。动态转换在运行时进行类型检查，如果不能进行转换则返回空指针或引发异常。

class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
// 将基类指针转换为派生类指针
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base);

• 常量转换（Const Cast）:常量转换用于将 const 类型的对象转换为非 const 类型的对象。常量转换只能用于转换掉 const 属性，不能改变对象的类型。

const int i = 10;
int& r = const_cast<int&>(i); // 常量转换，将const int转换为int

• 重新解释转换（Reinterpret Cast）：重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。重新解释转换不进行任何类型检查，因此可能会导致未定义的行为。

int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型

typedef 与 #define 的区别

• 执行时间不同：关键字 typedef 在编译阶段有效，由于是在编译阶段，因此 typedef 有类型检查的功能。#define 则是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查。

typedef unsigned int UINT;
 
void func()
{
    UINT value = "abc";  // error C2440: 'initializing' : cannot convert from 'const char [4]' to 'UINT'
    cout << value << endl;
}

• 功能有差异：typedef 用来定义类型的别名，定义与平台无关的数据类型，与 struct 的结合使用等。#define 不只是可以为类型取别名，还可以定义常量、变量、编译开关等。
• 作用域不同：#define 没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。

void func1()
{
    #define HW "HelloWorld";
}
 
void func2()
{
    string str = HW;
    cout << str << endl;
}

而typedef有自己的作用域

void func1()
{
    typedef unsigned int UINT;
}
 
void func2()
{
    UINT uValue = 5;  //error C2065: 'UINT' : undeclared identifier
}

class A
{
    typedef unsigned int UINT;
    UINT valueA;
    A() : valueA(0){}
};
 
class B
{
    UINT valueB;
    //error C2146: syntax error : missing ';' before identifier 'valueB'
    //error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
};

上面例子在B类中使用UINT会出错，因为UINT只在类A的作用域中。此外，在类中用typedef定义的类型别名还具有相应的访问权限：

class A
{
    typedef unsigned int UINT;
    UINT valueA;
    A() : valueA(0){}
};
 
void func3()
{
    A::UINT i = 1;
    // error C2248: 'A::UINT' : cannot access private typedef declared in class 'A'
}

而给UINT加上public访问权限后，则可编译通过。

class A
{
public:
    typedef unsigned int UINT;
    UINT valueA;
    A() : valueA(0){}
};
 
void func3()
{
    A::UINT i = 1;
    cout << i << endl;
}

• 对指针的操作：二者修饰指针类型时，作用不同：

typedef int * pint;


#define PINT int *
 
int i1 = 1, i2 = 2;
 
const pint p1 = &i1;    //p不可更改，p指向的内容可以更改，相当于 int * const p;
const PINT p2 = &i2;    //p可以更改，p指向的内容不能更改，相当于 const int *p；或 int const *p；
 
pint s1, s2;    //s1和s2都是int型指针
PINT s3, s4;    //相当于int * s3，s4；只有一个是指针。
 
void TestPointer()
{
    cout << "p1:" << p1 << "  *p1:" << *p1 << endl;
    //p1 = &i2; //error C3892: 'p1' : you cannot assign to a variable that is const
    *p1 = 5;
    cout << "p1:" << p1 << "  *p1:" << *p1 << endl;
 
    cout << "p2:" << p2 << "  *p2:" << *p2 << endl;
    //*p2 = 10; //error C3892: 'p2' : you cannot assign to a variable that is const
    p2 = &i1;
    cout << "p2:" << p2 << "  *p2:" << *p2 << endl;
}

结果：

p1:00EFD094 *p1:1
p1:00EFD094 *p1:5
p2:00EFD098 *p2:2
p2:00EFD094 *p2:5

• 还可以用 typedef 来定义与平台无关的类型。比如定义一个叫 FALSE 的浮点类型，在目标平台一上，让它表示最高精度的类型为：

typedef long double FALSE;

在不支持 long double 的平台二上，改为：

typedef double FALSE;

在连 double 都不支持的平台三上，改为：

typedef float FALSE;

也就是说，当跨平台时，只要改下 typedef 本身就行，不用对其他源码做任何修改。标准库就广泛使用了这个技巧，比如 size_t。

• 另外，因为 typedef 是定义了一种类型的新别名，不是简单的字符串替换，所以它比宏来得稳健（虽然用宏有时也可以完成以上的用途）。为了方便枚举的使用，应该和 typedef 结合使用，例如：

typedef enum BAYER_PATTERN{
    BAYER_RG = 0,
    BAYER_BG,
    BAYER_GR,
    BAYER_GB
}BAYER_PATTERN;

使用的时候就不用再 enum BAYER_PATTERN color = BAYER_RG; 了，而可以直接用:

BAYER_PATTERN color = BAYER_RG;

• 不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。

• C/C++ 编译 cpp 文件是从上往下编译，所以 main 函数里面调用其他函数时，如果其他函数在 main 函数的下面，则要在 main 函数上面先声明这个函数。或者把 main 函数放在最下面，这个不仅限于 main 函数，其他函数的调用都是如此。被调用的函数要在调用的函数之前声明。

// 函数声明
int func();


int main()
{
    // 函数调用
    int i = func();
}


// 函数定义
int func()
{
    return 0;
}

• 若参与运算的类型不同，则先转换成同一类型，然后进行运算。转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。若两种类型的字节数不同，转换成字节数高的类型。若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型。

• 所有的浮点运算都是以双精度进行的，即使仅含float单精度值运算的表达式，也要先转换成double型，再作运算。

• char型和short型参与运算时，必须先转换成int型。

• 在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度:

int a=1;
double b=2.5;
a=b;
cout << a; //输出为 2，丢失小数部分
int a = 1;
double b = 2.1;
cout << "a + b = " << a + b << endl;  //输出为a + b = 3.1

扫码关注公众号，查看更多精彩内容