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

 

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

热门相关:嫡女谋:逆天三小姐   嫡女谋:逆天三小姐   学霸,你女朋友掉了   美漫之大冬兵   隐婚365天:江少,高调宠!