c++随笔-5

已于 2024-03-28 00:05:34 修改
阅读量106 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2022-03-13 19:31:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/123464376
版权

类基础

// 定义类
class CAnimal {   // 类关键字 class，类名 CAnimal
public:           // 成员访问控制符，public 表示对其他类可见
    CAnimal(){}   // 无参构造函数，创建类对象时自动调用，注意构造函数名即为类名，无返回值
    ~CAnimal(){}  // 析构函数，类对象销毁时自动调用，注意析构函数名即为 ~类名，无返回值

    void SetName(const std::string &name) {  // 类成员函数
        this->m_name = name;   // m_name = name 也可以
    }
private:  // private 表示对其他类不可见
    std::string m_name;   // 类成员变量
};   // 注意结尾分号，class XXX {}; 这是一个空类，编译时自动创建无参构造和析构函数

int main () {
    CAnimal animal;    // 类对象声明(栈)
    animal.SetName("cat");   // .(点)，栈对象会引用对象调用类成员方式
    CAnimal &refAnimal = animal;
    refAnimal.SetName("cat2"); 
    CAnimal *panimal = new CAnimal;  // 类对象声明(堆或自由存储区)
    panimal->SetName("dog");  // ->(箭头)，指针对象调用类成员方式
    delete panimal;

    return 0;
}
  • 面向过程编程(函数式编程)和面向对象编程(OOP)是两种不同的编程思想
  • OOP通过对实际事物的特征进行分析和抽象，形成不同事物特征的集合，c++中对于这种现象提供类来描述
  • 类定义好后在成员函数里，编译器默认会将类自己(this)作为指针参数传递进去，使用 this 指针表示，实际上类访问内部成员时不添加this也可以调用
  • c++的访问控制符有三种，public(公有的) private(私有的) protected(受保护的)
  • 不写访问控制符时，c++的类默认访问权限为私有的，struct 默认访问权限为公有的

函数重载

void Print() {
    std::cout << "Print()" << std::endl;
}
void Print(int, int) {
    std::cout << "Print(int, int)" << std::endl;
}
void Print(int, double) {
    std::cout << "Print(int, double)" << std::endl;
}
void Print(double, int) {
    std::cout << "Print(double, int)" << std::endl;
}

int main(int argc, char *argv[])
{
    // 函数重载规则
    // 1. 函数名称相同
    // 2. 函数形参不同(包括：形参数量、形参类型、形参排列顺序等)
    // 3. 函数返回值不作为函数重载的判断依据

    // 重载函数匹配规则
    // 1. 精确匹配：无强制或隐式类型转换，数组做函数参数退化为指针等情况
    // 2. 提升匹配：自动隐式转换(如bool 到 int、char到int、short 到int、int 到 double、float 到 double等等)
    // 3. 强制转换调用某个重载函数
    // 4. 无匹配函数
    // 5. 注意函数参数设置，防止出现函数调用二义性(有多个满足条件的调用，编译器不知道调用哪个)

	// 实际写的函数经过编译后函数名称根据情况，c++编译器会进行命名倾轧(即添加一些字符进行改变)，不同重载函数最终在编译时也是不同的函数名称

	// 运算符重载
    // 1. c++中绝大多数运算符也可以重载，使用 operator 关键字，不能创建新运算符，重载需遵守运算符规则
	// 2. 不能重载的运算符 .(成员运算符) .*(成员指针运算符) ::(作用域运算符) ?:(条件运算符) sizeof(sizeof运算符) typeid(一个RTTI运算符) 四个强制类型转换运算符
    // 3. 重载运算符 () [] -> 或 = 时，只能重载为成员函数，不能重载为全局函数

    Print();
    Print(1, 1);
    Print(1, 4.0);
    Print(4.0, 1);
    return 0;
}

输出结果：
Print()
Print(int, int)
Print(int, double)
Print(double, int)

类成员变量初始化

class CAnimals {
public:
    CAnimals()
        : m_name("cat"){  // 无参构造，使用初始化列表赋值，这样比写在函数中初始化时间早，且 const 修饰的成员变量赋值不能写在函数中
        std::cout << "CAnimals()" << std::endl;
    }
    CAnimals(const std::string &name)
        : m_name(name){  // 有参构造
        std::cout << "CAnimals(const std::string &name)" << std::endl;
    }
    CAnimals(const CAnimals& other) {  // 拷贝复制构造，对象和对象之间的拷贝复制
        this->m_name = other.m_name;
        std::cout << "CAnimals(const CAnimals& other)" << std::endl;
    }
    CAnimals& operator = (const CAnimals& other) {    // 对象间的赋值运算(对赋值运算符 = 重载)
        if (this == &other)   // 避免自赋值
            return *this;
        this->m_name = other.m_name;
        std::cout << "CAnimals& operator = (const CAnimals& other)" << std::endl;
        return *this;
    }
    ~CAnimals() {
        std::cout << "~CAnimals" << std::endl;
    }

private:
    std::string m_name;  // std::string m_name = "";
};

int main(int argc, char *argv[])
{
    std::cout << "Create object a: " << std::endl;
    CAnimals a;
    std::cout << "Create object b: " << std::endl;
    CAnimals b("dog");
    std::cout << "Create object c: " << std::endl;
    CAnimals c(a);
    std::cout << "Create object d: " << std::endl;
    CAnimals d = b;
    std::cout << "Create object e: " << std::endl;
    CAnimals e;
    e = d;
    // 析构顺序为 e d c b a，与构造顺序相反
    return 0;
}

输出结果：
Create object a:
CAnimals()
Create object b:
CAnimals(const std::string &name)
Create object c:
CAnimals(const CAnimals& other)
Create object d:
CAnimals(const CAnimals& other)
Create object e:
CAnimals()
CAnimals& operator = (const CAnimals& other)
~CAnimals
~CAnimals
~CAnimals
~CAnimals
~CAnimals

  • 函数成员变量初始话在较新c++标准里可以直接在定义时赋值初始化
  • 类中没有显示写构造析构函数时、编译器默认会生成(默认无参构造，析构，拷贝复制构造和赋值运算函数，c++11及以上标准多了右值赋值)
  • 在构造函数中初始化，如果类中存在构造函数，编译器就不会自动生成默认无参构造，若需要无参构造就编码写出来
  • 函数形式参数不涉及到修改的尽量添加 const 修饰
  • 拷贝复制构造和赋值运算需要手动去重新实现的情况：类成员中有指针或引用变量时必须注意，根据实际情况是否需要实现，否则会有造成程序崩溃的隐患

友元

class CDemo;   // 类前置声明

class CAnimals {
public:
    void SetName(const std::string &name) {
        m_name = name;
    }

    void Print(const CDemo &obj);
private:
    friend void Print(const CAnimals& obj);  // 友元函数声明
    std::string m_name = "Cat";

    friend CDemo;    // 友元类声明
};

void Print(const CAnimals& obj) {
    std::cout << "CAnimals Print: " << obj.m_name << std::endl;
}

class CDemo {
public:
    void Print(const CAnimals& obj) {
        std::cout << "CDemo Print: " << obj.m_name << std::endl;
    }

    friend void CAnimals::Print(const CDemo &obj);  // 友元成员函数

    friend std::ostream &operator << (std::ostream &os, const CDemo& obj); // 重载 << 运算符
private:
    std::string m_name = "Dog";
};

std::ostream &operator << (std::ostream &os, const CDemo& obj) {
    return (os << "operator <<: " << obj.m_name << '\t');
}

void CAnimals::Print(const CDemo &obj) {
    std::cout << "CAnimals::Print: " << obj.m_name << std::endl;
}

int main(int argc, char *argv[])
{
    CAnimals obj;
    Print(obj);
    CDemo demo;
    demo.Print(obj);
    obj.Print(demo);

    std::cout << demo << "ok" << std::endl;
    return 0;
}

输出结果：
CAnimals Print: Cat
CDemo Print: Cat
CAnimals::Print: Dog
operator <<: Dog ok

  • 友元包括友元函数、友元类，友元成员函数，由于c++的访问控制符，对于某个类中的 private 权限的成员，类外边不可访问，只能类中访问
  • 友元会打破类的封装性(访问权限)，合理设计使用
  • 重载 << 运算符最好作为友元函数

浅拷贝深拷贝

// 使用编译器创建的拷贝复制构造函数(浅拷贝)和赋值函数(浅拷贝)，注意观察输出 address
class CAnimal {
public:
    CAnimal()
        : m_property(new char[11]){
        for (int i = 0; i < 10; ++i)
            m_property[i] = i + 97;
    }

    void Print() {
        printf("address: %p\n", &m_property[0]);
        for (int i = 0; i < 10; ++i)
            std::cout << m_property[i] << "\t";
        std::cout << std::endl;
    }
private:
    char *m_property = nullptr;
};

int main(int argc, char *argv[])
{
    CAnimal a;
    a.Print();
    CAnimal b = a;
    b.Print();
    CAnimal c(a);
    c.Print();
    CAnimal d;
    d = a;
    d.Print();
    return 0;
}

输出结果：
address: 0000000000fe17b0
a b c d e f g h i j
address: 0000000000fe17b0
a b c d e f g h i j
address: 0000000000fe17b0
a b c d e f g h i j
address: 0000000000fe17b0
a b c d e f g h i j

// class CAnimal 中添加拷贝复制构造函数(实现深拷贝)，注意观察输出 address
CAnimal(const CAnimal& other) {
    if (other.m_property == nullptr)
        return;

    if (this->m_property != nullptr)
        delete [] this->m_property;

    this->m_property = new char[strlen(other.m_property + 1)];    // 分配空间
    strcpy(this->m_property, other.m_property);     // 拷贝内容
}

输出结果：
address: 0000000000fb17b0
a b c d e f g h i j
address: 0000000000fb17d0
a b c d e f g h i j
address: 0000000000fb1b20
a b c d e f g h i j
address: 0000000000fb17b0
a b c d e f g h i j

// class CAnimal 中添加赋值函数(实现深拷贝)，注意观察输出 address
CAnimal &operator = (const CAnimal& other) {
    if (this == &other)  // 判断自赋值
        return *this;

    if (this->m_property != nullptr)   // 清空原内容
        delete [] this->m_property;

    this->m_property = new char[strlen(other.m_property + 1)];  // 分配空间
    strcpy(this->m_property, other.m_property);     // 拷贝内容
    return *this;
}

输出结果：
address: 00000000006f17b0
a b c d e f g h i j
address: 00000000006f17d0
a b c d e f g h i j
address: 00000000006f1b20
a b c d e f g h i j
address: 00000000006f1b40
a b c d e f g h i j

  • c++编译器默认创建(类中未显式写对应的构造时)的拷贝复制构造和赋值函数默认是浅拷贝
  • 浅拷贝：只复制某个对象的指针或引用，对象成员变量之间的赋值，若有指针或引用，仅仅只是指向的地址之间的赋值，两个指针或引用指向同一块内存空间
  • 深拷贝：深拷贝会完全复制整个对象，不共享内存空间，两个对象互不影响
  • 如果对象中没有指针或引用等资源时，深拷贝和浅拷贝没有什么区别

简单String类

class CMyString {
public:
    CMyString() {}
    CMyString(const char *data) {
        if (!data)
            return;

        m_pdata = new char[strlen(data) + 1];
        strcpy(m_pdata, data);
    }
    CMyString(const CMyString& other) {
        if (other.m_pdata == nullptr)
            return;

        m_pdata = new char[strlen(other.m_pdata) + 1];
        strcpy(m_pdata, other.m_pdata);
    }
    CMyString &operator=(const CMyString& other) {
        if (this == &other || other.m_pdata == nullptr)  // 此处编写时规则是 other.m_pdata 为空时，当前对象不改变，可修改
            return *this;

        if (m_pdata != nullptr)
            delete [] m_pdata;

        m_pdata = new char[strlen(other.m_pdata) + 1];
        strcpy(m_pdata, other.m_pdata);
        return *this;
    }
    CMyString operator + (const CMyString& other) {  // 重载 + 运算符
        if (other.m_pdata == nullptr)
            return *this;

        CMyString ret;
        int len = strlen(this->m_pdata) + strlen(other.m_pdata) + 1;
        char *p = new char[len];
        strcpy(p, this->m_pdata);
        strcpy(p + strlen(this->m_pdata), other.m_pdata);
        ret = p;
        delete [] p;
        return ret;
    }
    char &operator [] (size_t index) {    //  重载 [] 运算符
        if (index < 0 || index >= strlen(m_pdata))
            throw "over range";

        return m_pdata[index];
    }
    ~CMyString() {    // 析构函数
        if (m_pdata)
            delete [] m_pdata;
    }

    void Print() {   // 为打印方便，内置此打印函数
        if (m_pdata == nullptr)
            return;

        int len = strlen(m_pdata);
        for (int i = 0; i < len; ++i)
            std::cout << m_pdata[i] << '\t';
        std::cout << std::endl;
    }

private:
    char *m_pdata = nullptr;
};

int main(int argc, char *argv[])
{
    CMyString a;
    a = "HelloWorld";    // char * 类型初始化，调用 char * 类型构造函数
    a.Print();
    CMyString b("HelloWorld");
    b.Print();
    CMyString c = a;
    c.Print();
    CMyString d;
    d = b;
    d.Print();
    CMyString e = (d + b);
    e.Print();
    std::cout << "e[0]: " << e[0] << std::endl;
    e[0] = 'S';    // 修改值
    e.Print();
    return 0;
}

输出结果：
H e l l o W o r l d
H e l l o W o r l d
H e l l o W o r l d
H e l l o W o r l d
H e l l o W o r l d H e l l o W o r l d
e[0]: H
S e l l o W o r l d H e l l o W o r l d

  • 注意重载运算符

static

class CStatic {
public:
    static int m_id;   // 静态成员变量声明

    static int GetId () {  // 只能访问 static 修饰的内容
        return m_id;
    }
};

int CStatic::m_id = 10;    // 类内声明(一般在 .h 文件)、类外初始化(一般在 .cpp文件)

int main(int argc, char *argv[])
{
    // 静态成员变量和静态成员函数调用方式，属于类而不属于某个对象，所以使用 类名::静态内容
    std::cout << "Get id: " << CStatic::m_id << std::endl;
    std::cout << "Get id: " << CStatic::GetId() << std::endl;
}

输出结果：
Get id: 10
Get id: 10

  • static 修饰的变量或函数只能在当前文件可访问(如 a.h、a.cpp 中)，其它文件不可访问(如 b.h、b.cpp 中访问不了 a.h 中 static 修饰的内容)
  • static 可修饰全局变量、局部变量、全局函数、局部函数、类成员变量和函数等
  • static 修饰的内容存储在静态数据区，所以其生命周期是整个程序运行时，程序退出才销毁
  • static 修饰的变量具有默认初始化值
  • static 修饰的类静态成员函数是属于整个类而非类的对象，没有this指针，所以仅能访问类的静态数据和静态成员函数
  • 静态数据成员初始化的格式 <数据类型><类名>::<静态数据成员名> = <值>
无夜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ MD5 摘要方法工程
04-22
**C++ MD5 摘要方法工程** 在信息技术领域，MD5（Message-Digest Algorithm 5）是一种广泛使用的加密散列函数，产生一个128位（16字节）的散列值，通常表示为32个十六进制数字。这个C++ MD5摘要工程是为了帮助...
c++的一些随笔
01-28
一些随手笔记关于c++
c++随笔-删除文件
CSDN_Anonymous的博客
06-07 4653
c++删除文件非常简单，只需remove("文件名")即可。 需要包含#include<windows.h>头文件。 一般情况下，remove
c++随笔-4
TimerSea的博客
03-10 898
本文介绍c++中define、typedef、const、引用、函数等相关知识
C++随笔-野指针
qq_34202054的博客
02-23 507
野指针 指向”垃圾“内存的指针可称为野指针。 指针变量没有初始化。 int* a; *a = 123; 编译结果： 已经不用的指针变量没有置为NULL。 指针的操作超出了变量的作用范围。
C++随笔-数据类型
qq_34202054的博客
02-14 298
名称 字节 范围 char 1 有符号(signed):-128到127；无符号(unsigned):0到255 short int(short) 2 有符号(signed):-32768到32767；无符号(unsigned):0到65535 long int(long) 4 有符号(signed):-2,147,483,647 到 2,147,483,647；无符号(unsigned):0到4,294,967,295 int 4 有符号(signed):–2147483648...
C++随笔－名称空间
ZerinHwang
04-28 164
C++中的声明区域、潜在作用域、作用域 声明区域：允许对某变量进行声明的区域 潜在作用域：是声明区域的子集。从某变量声明处开始，到某变量声明结束为止，都是某变量的潜在作用域。 作用域：是某变量潜在作用域的子集，为程序中，某变量实际可见的区域范围。 由此可见，只要在不同的声明区域对变量进行声明，就能将该变量加入相应的声明区域，进一步得到相应的该变量的作用域。而通过对变量在不同声明区域以及使用不...
C++随笔－友元函数
ZerinHwang
05-04 118
注意友元函数的身份：非类成员函数。作为类的友元函数，其所获得的只是和类成员函数一样访问类对象的权利，但不代表其可视为类成员函数，理所当然其不可以通过" . "被调用。 值得注意的是，通过友元，函数被赋予了访问类对象的权限，其中包括允许访问类的私有（private）和保护（protected）成员。这才是最重要的，因为公有（public）部分直接通过“ . ”方法就可以实现对其的访问。以及在友元函...
C++随笔－程序的创建
ZerinHwang
01-29 169
程序创建的过程 step1:用文本编辑器编写程序，并将其保存至文件中，这个文件就是程序的源代码 step2:编译源代码。通过运行一个程序，将源代码翻译成计算机使用的内部语言，即机器语言。包含了翻译后的程序的文件即目标代码 step3:链接。将目标代码与其他代码链接起来。链接指的是将目标代码同使用的函数的目标代码以及一些标准的启动代码组合起来，生成程序的运行阶段版本。包含该最终产品的文件称为可...
随笔 - C++实现栈
m0_46684679的博客
08-27 990
老年人康复运动，C++实现一个栈。
随笔-c++-头文件
weixin_43937991的博客
03-26 87
stdc++.h vs的include 包含此路径Mingw\lib\gcc\mingw32\6.3.0\include\c++\mingw32\bits
C++随笔－main()函数
ZerinHwang
01-29 191
因为文本编辑器中编写的代码实际上是要拿给编译器看的，是要由编译器翻译成目标代码之后再经过链接才得到可执行文件，所以需要让编译器知道一个程序的开始与结束。所以实际上最终供计算机使用的代码实际上是由编译器产生的代码，和源代码并不相同，是经过加工过的。 而定义main()函数，实际上也是在告诉编译器，这个是程序的入口。至于为什么是main()函数，其实这只是编译器的规定。因为源代码是拿给编译器看的，所...
C++ 对文件进行md5的方法
04-22
在C++中实现对文件进行MD5计算的方法，可以分为以下几个步骤： 1. **包含库文件**：首先，你需要包含处理二进制数据和MD5计算的库。在提供的`md5.h`文件中，可能会定义了MD5算法的实现。通常，这些库会提供MD5...
c++计算eigen随笔(8)-数组、矩阵、向量（1）
01-20
4 5 6 ``` 当输出 `x1` 时，可以看到其打印结果与预期相符。值得注意的是，由于`x1`的大小在编译时已知，它通常会被存储在栈上，这比在堆上分配内存更快且更节省资源。 总的来说，Eigen库提供了丰富的功能来处理...
C++ Primer 中文版（第 5 版）第一章——随笔（含练习）-源码
04-10
源码
C++ 多态
wxk2227814847的博客
07-10 781
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 370
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ 生成随机字符串
m0_56306892的博客
07-15 80
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
最新发布
tyfwin的博客
07-15 585
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
download c++ 2015-2019 redistributable
05-13
C++ 2015-2019可重发行组件是一款由微软公司提供的基于C++的软件开发包。当用户在计算机中运行需要使用到C++的应用程序或游戏时，需要下载和安装此软件以确保应用程序或游戏能够正常运行。同时，用户还可以通过安装此C++可重发行组件来解决由于缺少C++ 2015-2019运行库导致的一些错误。 为了保证应用程序或游戏能够使用到最新的C++语言功能和库，微软公司不断的更新并发布新的可重发行组件，而用户可以直接在微软官网下载和安装最新版本的 C++ 2015-2019 可重发行组件。 安装 C++ 2015-2019 可重发行组件非常简单，只需要下载完整的安装包，然后按照提示完成安装过程即可。此外，用户可以根据实际需要选择不同版本的安装包，包括 32 位和 64 位系统的版本。 总之，下载和安装 C++ 2015-2019 可重发行组件是确保一些应用程序或游戏正常运行的必要过程，用户可以根据实际需求完成安装。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值