小白程序员C++学习笔记（包含摘抄记录）

最新推荐文章于 2021-08-03 10:13:31 发布
最新推荐文章于 2021-08-03 10:13:31 发布
阅读量184 收藏
点赞数 1
分类专栏： 学习记录 文章标签： c++ 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangxiaoywc/article/details/106384729
版权

这个博客是我这个小白程序员工作中学习的记录，首要作用是作为自己的笔记，如果能帮到他人就更好，如果有大神帮忙指点那就更更更好！！

1.virtual关键字，基类指针调用，如果不加virtual无法调用派生类重写的。

#include <iostream>
using namespace std;
class A
{
public:
    A();
    ~A();
    virtual void f()
    {
        cout << "A" << endl;}
    };
A::A(){}
A::~A(){}

class B : public A
{
public:
    B();
    ~B();
    void f()
    {
        cout << "B" << endl;
    }
};
B::B(){}
B::~B(){}

void main()
{
    A* a = new B;
    a->f();
    system("pause");
}

加virtual输出B，不加virtual输出A

2.在函数后加const的意义

const char getData {return this->letter;}
char getData() const {return this->letter;}
  • 前面使用const 表示返回值为const

  • 后面加 const表示函数不可以修改class的成员

3.C++11强枚举类型enum class

在标准C++中，枚举类型不是类型安全的。枚举类型被视为整数，这使得两种不同的枚举类型之间可以进行比较。C++03 唯一提供的安全机制是一个整数或一个枚举型值不能隐式转换到另一个枚举别型。 此外，枚举所使用整数类型及其大小都由实现方法定义，皆无法明确指定。 最后，枚举的名称全数暴露于一般范围中，因此C++03两个不同的枚举，不可以有相同的枚举名。
(好比 enum Side{ Right, Left }; 和 enum Thing{ Wrong, Right }; 不能一起使用。)

C++11 引进了一种特别的 "枚举类"，可以避免上述的问题。使用 enum class 的语法来声明：
enum class Enumeration{ Val1, Val2, Val3 = 100, Val4 /* = 101 */,};
此种枚举为类型安全的。枚举类型不能隐式地转换为整数；也无法与整数数值做比较。 (表示式 Enumeration::Val4 == 101 会触发编译期错误)。

#include <iostream>
using namespace std;

enum class Enumeration1
{
    Val1, //0
    Val2, //1
    Val3 = 100, //100
    Val4  //101
};

4.__declspec(dllexport)

https://www.jianshu.com/p/ea45468f25f1

5.inline

https://www.cnblogs.com/Cqlismy/p/11153449.html

6.void作形参

c语言中的void 基本上就是两个意思：
无，没有
任意类型
这两个意思，与void出现的代码位置和修饰变量相关：
函数返回值位置，如：
void func(int i) ; //表示func（）函数没有返回值，void不可省
函数参数位置，如：
void func( void ) ; //表示func（）函数即没有返回值，也没有参数。这里括号中的void可省。
修饰指针变量（一般多用于函数参数）
int func( void *a, void *b) ; //表示形参a b可以是任意类型指针变量
修饰常量（一般用于宏定义）
#define NULL ((void*)0) //这里NULL从数值上讲就是0，但这样写，可以表明NULL是个（任意）指针类型数据

7. __FILE__、__FUNCTION__、__LINE__

__FILE__&__FUNCTION__  类型为 char*

__LINE__  类型为int

8.substr()

0. 用途：一种构造string的方法

1. 形式：s.substr(pos, n)

2. 解释：返回一个string，包含s中从pos开始的n个字符的拷贝（pos的默认值是0，n的默认值是s.size() - pos，即不加参数会默认拷贝整个s）

3. 补充：若pos的值超过了string的大小或者为负，则substr函数会抛出一个out_of_range异常；若pos含有小数则会自动向下取整；若pos+n的值超过了string的大小，则substr会调整n的值，只拷贝到string的末尾（包含n等负数）

9.std::string::find_first_of

string (1) 
size_t find_first_of (const string& str, size_t pos = 0) const noexcept;
c-string (2) 
size_t find_first_of (const char* s, size_t pos = 0) const;
buffer (3) 
size_t find_first_of (const char* s, size_t pos, size_t n) const;
character (4) 
size_t find_first_of (char c, size_t pos = 0) const noexcept;

在字符串中搜索与参数中指定的任何字符匹配的第一个字符。

当指定了pos时，搜索只包括pos或pos之后的字符，忽略pos之前可能出现的任何字符。

注意，只要序列中的一个字符匹配（而不是所有字符）就足够了

10.dynamic_cast

将基类指针或引用转换为派生类的指针或引用

基类必须有虚函数，否则编译错误

例：

class Base
{
    public:
    Base(){}
    public:
    virtual ~Base(){}
}

class Derived : public Base
{
    public:
        Derived();
    public:
    ~Derived();
}

void main()
{
   Base* pt1 = new Base();
   Derived* pt = dynamic_cast<Derived>(pt1); 
}

11.define中的三个特殊符号：#，##，#@

#define Conn(x,y) x##y
#define ToChar(x) #@x
#define ToString(x) #x

void main()
{
    // ## x连接y
    int n = Conn(123,456);          // n = 123456
    char* str = Conn("abc", "efg"); // str = "abcdef"
    // #@ 给x加单引号返回const char
    char a = ToChar(1);             // a = '1'
    // # 给x加双引号
    char* str = ToString(123456);   // str = "123456"
}

12.虚

参考下面代码，子类存在函数func那么父类所有名为func的函数(包括所有重载的函数，返回值不同的，被const修饰等区别)都将被子类的函数func覆盖(overwrite---可理解为覆盖，子类覆盖了父类所有同名函数)，所以Derived对象并不存在func(int x)函数

#include<iostream>
class Base{
public:
    virtual void func(){}				
    virtual void func(int x){}
};

class Derived:public Base{
public:
    //overwrite父类所有名为func的函数
    virtual void func(){}
};

int main()
{
    Base* pa = new Derived();
    pa->func();
    pa->func(10);
    delete pa;
    
    Derived* pb = new Derived();
    pb->func();
    //这个调用将会报错，Derived类func()覆盖了所有Base类中名为func的函数
    //所以Derived类并没有与func(int x)这个函数
    pb->func(10);	
    delete pb;
}

13.2020-08-19 今天把全局变量当做静态变量，导致Bug久久未发现，记录在此，以此为戒！

14.C++静态成员变量

C++静态成员变量：

  1. 必须在外部定义和赋值；
    • 不能在 main() 函数中定义
    • 不能在类的构造函数中定义
  2. 必须要定义静态变量，否则该变量没有内存空间（类中只是申明） ；
  3. 类本身可以直接调用静态变量
  4. 静态变量依旧符合public、private、protect特性

参考链接：https://www.runoob.com/w3cnote/cpp-static-usage.html

15.C++静态成员方法

1、静态方法可以被类直接调用，但是同静态变量一样符合public、private、protect特性

2、静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。

3、静态成员函数不可以同时声明为 virtual或后缀const 函数。因为virtual就是用来区分是哪个对象调用了他，与静态方法矛盾。而后缀const是用来修饰this指针的，静态变量中不包含this指针。

16.函数指针

int sum(int x, int y)
{
    return x + y;
}

int main()
{
    int (*p)(int, int) = sum;
    int x = (*p)(1,2);        //!< 调用传参
}

17.拷贝构造函数

调用时机：

    ①函数的参数为类对象

    ②函数返回值是类对象

    ③通过对象初始化对象

A a(1);
A b(a);

18.断言

如果它的条件返回错误，则终止程序执行（debug模式，用于调试）

#include "assert.h"
#include "crtdbg.h"

int main(int argc, char* argv[])
{
    int i=5;
    assert( i >= 6);   //包含在 assert.h 头文件中  此函数会将错误信息显示在命令行中，在命令行中        显示出错的语句和行数
    _ASSERTE( i >= 6);   //包含在 crtdbg.h 头文件中  此宏会显示出在此宏中的语句
    ASSERT( i >= 6);      //包含在 crtdbg.h 头文件中 此宏不会显示在此宏中的语句，而只是显示出错的行数
}

在调试结束后，可以通过在包含#include 的语句之前插入 #define NDEBUG 来禁用assert()调用

#define NDEBUG
#include "assert.h"

19.静态变量只初始化一次

#include<iostream>

using namespace std;

int func()
{

 static bool temp = true;//静态变量初始化一次

 if (temp)
 {
     cout << "Test" << endl;
 }

 temp = false;
 return 0;
}

int main()
{
 while (1)
     {
          func();
     }
}

20.inline 内联函数

21.特殊字符以UTF-8输出

字符串前面加u8，source文件以UTF-8格式保存

std::string str = u8"Test";

22.友元函数和友元类

  友元类：

一个类 A 可以将另一个类 B 声明为自己的友元，类 B 的所有成员函数就都可以访问类 A 对象的私有成员。在类定义中声明友元类的写法如下：

class CCar
{
private:
    int price;
    friend class CDriver;  //声明 CDriver 为友元类
};
class CDriver
{
public:
    CCar myCar;
    void ModifyCar()  //改装汽车
    {
        myCar.price += 1000;  //因CDriver是CCar的友元类，故此处可以访问其私有成员
    }
};
int main()
{
    return 0;
}

  友元函数：

#include <iostream>
 
using namespace std;
 
class Box
{
   double width;
public:
   friend void printWidth( Box box );  // 注意这个声明为友元的函数并不是Box的成员函数
   void setWidth( double wid );
};

// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{
   /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
   cout << "Width of box : " << box.width <<endl;
}

23.volatile

24.Lambda表达式

Lambda 函数可以引用在它之外声明的变量. 这些变量的集合叫做一个闭包. 闭包被定义在 Lambda 表达式声明中的方括
号 [] 内。这个机制允许这些变量被按值或按引用捕获

  []    未定义，使用任何外部变量都是错误的（编译错误）

  [&]  按引用捕获外部变量

  [=]   按值捕获外部变量

  [x, &y]  x按值捕获，y按引用捕获

  [=, &z]  z按引用捕获，其他按值捕获  

void test5()
{
    int x = 1;
    //auto func1 = []() {cout << x << endl; }; //!< 编译错误，空白表示不使用任何参数，仅可使用形参列表中的参数
    auto func2 = [&]() {cout << x << endl; };
    auto func3 = [=]() {cout << x << endl; };
    //auto func4 = [=]() { x = 3; };           //!< 编译错误，按值传递无法修改
    auto func5 = [=]()mutable { x = 3; };      //!< 按值传递使用mutable可以修改，但只是修改副本
    auto func6 = [&]() { x = 3; };

    x = 2;
    func2(); //!< 输出 2，按引用值可以修改
    func3(); //!< 输出 1，按值传递，在穿件func3时值已经确定（副本）

    func5(); 
    cout << x << endl; //!< 输出 2，按值传递func5修改的是x的副本
    func6();
    cout << x << endl; //!< 按引用传递，值被改变
}

 

凉小
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员C++学习笔记
05-08
哔站课程详细笔记，此处更新到STL持续更新
【C++ 关键字 virtual 】C++ virtual 关键字(将成员函数声明为虚函数实现多态
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-08 1330
在C++的早期设计中，通过基类指针可以访问派生类的成员变量，这是由于派生类对象在内存中的布局是基类成员变量在前，派生类成员变量在后。因此，当我们使用基类指针指向派生类对象时，可以正常访问到派生类中从基类继承来的成员变量。 然而，对于成员函数，情况就不同了。在编译时期，成员函数并不会被放入对象的内存空间中，而是存放在一块单独的内存区域，每个类只有一份成员函数的代码。当我们通过基类指针调用成员函数时，编译器会根据指针的静态类型（也就是基类类型）去查找对应的成员函数，而不是动态类型（也就是实际指向的派生类类型）
虚拟成员函数
weixin_55255164的博客
07-19 197
成员函数 Virtual Member Functions 每个声明了虚函数或者继承了有虚函数的类，都会有一个自己的vtbl。同时该类的每个对象都会包含一个vptr去指向该vtbl。虚函数按照其声明顺序放于 vtbl 表中, vtbl 数组中的每一个元素对应一个函数指针。如果子类覆盖了父类的虚函数，将被放到了虚表中原来父类虚函数的位置。 如果 normalize()是一个 virtual member function，那么调用：ptr->normalize(); 实际上会被编译器转化为：(*ptr
虚函数（virtual）
qq_37200329的博客
09-03 4169
虚函数（virtual） 上面提到动态多态主要通过虚函数机制实现，这里介绍以下虚函数。和普通的函数声明方式相同，只要在函数的返回值前加上virtual关键字，该函数就为虚函数，即virtual 函数类型 函数名（形式参数） 虚函数的作用：允许通过基类的指针或引用来访问基类和派生类的同名函数。 1、虚成员函数 #include <iostream> using namespac...
cpp——类——virtual成员函数
mardax的专栏
02-28 1436
VTBL non-static成员函数分两类： non-virtual成员函数 virtual成员函数 如果类包含virtual成员函数，就会生成虚函数表，即VTBL(virtual table)，VTBL包含类的virtual成员函数入口地址： 包含VTBL的类，其第一个字段为vptr指针，指向类的VTBL，因此VTBL被所有类实例对象共享 子类VTBL继承父类VTBL，子类可增加VTBL项(增加virtual成员函数)，更新VTBL项(override virtual成员函数)，override vi
黑马程序员 c++视频学习详细笔记
03-11
建议结合博主博文学习
程序员面试学习笔记以及相关经验记录
11-16
程序员面试学习笔记以及相关经验记录
黑马程序员C++学习资料
最新发布
12-22
主要包括黑马程序员从零开始学习C++的第一阶段资料，适用于C++学习新手入门，包括讲义代码以及相关资源文件。
一个C++程序员的学习经历
02-03
看见大家在这里畅所欲言，有高手也有新入门的ddmm，我也来谈谈学VC的一点“捷径”吧，这条“捷径”纯粹走的是C/C++的路子，不考虑学习其他语言。（我只会C/C++，略懂VB和Java，所以对于通过其他语言来切入VC的没有...
4.2 虚拟成员函数
Virtual_Func的博客
08-14 659
Q1：C++多态形式：静态多态性、动态多态性• 多态：以一个 “public base class” 的指针寻址出一个 “derived class object”（深入探索C++对象模型定义）• 静态多态性通常称为编译时多态，到底模板是不是多态？？？我个人认为不是• 动态多态性通常称为运行时多态，通过虚函数来实现• 动态多态性的两个条件：○ 在基类中必须使用虚函数或纯虚函数○ 调用函数时使用基类的
类成员函数继承（virtual、非virtual）
jfkidear的专栏
12-13 1006
类成员函数继承（virtual、非virtual） 分类：2011-03-14 09:54 404人阅读 评论(0) 收藏 举报 deleteclass2010 转帖地址：http://www.cppblog.com/liyuxia713/archive/2010/01/08/105170.html  类继承 ★ 对于父类函数（virtual、非virtu
Virtual Member Functions(虚拟成员函数)
ZZHinclude的博客
08-03 299
实现模型：每一个class 只会有一个virtual table，内含该class之中有作用的virtual function的地址，每一个object有一个vptr(多继承可能有多个)，指向virtual table的所在。 虚函数的地址以及存放虚函数地址的虚表在编译时期就确定下来了，不需要执行期的介入。执行期要做的是，激活虚函数 1.单一继承 单一继承的原理： ①继承基类的虚函数实体：基类所有虚函数实体的地址会被拷贝到derived class的virtual table相对应的slot之中。 ②重写
virtual成员函数
weixin_30684743的博客
03-18 143
一，虚函数一般实现模型： 每一个类只要含有虚函数，就会创建一个虚函数表，里面包含的虚函数的地址，每个类对象里面包含一个指针（vptr）指向这个虚函数表。（ps基于主流编译器的，标准并未规定）下面我们来测试一下： #include<iostream> using namespace std; class A { private: in...
浅谈virtual函数与其他成员函数
u010462274的专栏
11-05 670
前几天在北京听了一个百度da
黑马程序员c++笔记
08-12
很抱歉，我是一个AI助手，无法提供具体的黑马程序员C++笔记。但是，你可以在CSDN上搜索"黑马程序员C++笔记"，可能会找到相关的资源。此外，你也可以参考一些经典的C++教材和在线教程，例如《C++ Primer》、《C++标准...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值