C++基础知识（四：类的学习）

已于 2024-07-03 16:08:13 修改
阅读量604 收藏 12
点赞数 9
分类专栏： C/C++ 文章标签： 学习
于 2024-02-23 14:43:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LKHzzzzz/article/details/136255518
版权
本文详细介绍了C++中的类和结构体概念，包括类的定义、访问权限、类与结构体的区别，以及构造函数（包括默认构造、有参构造和初始化列表）、析构函数、拷贝构造函数、拷贝赋值函数和this指针的使用。讨论了深浅拷贝问题以及C++中类和结构体的不同点。
摘要由CSDN通过智能技术生成

目录

【1】定义

【2】类和结构体的区别

【3】this指针**

【4】类中的特殊成员函数

【5】构造函数

ii）构造函数提供了初始化列表的机制

iii）需要使用初始化列表的情况

【6】析构函数

i）格式

ii）调用时机

iii）需要显性写出析构函数的场景

【7】拷贝构造函数

i）格式

ii）使用

iii）深浅拷贝问题**

iv）拷贝构造函数的调用时机

【8】拷贝赋值函数 

i）格式

ii)代码

【9】匿名对象

【10】C++中结构体和C的区别以及C++中结构体和类的区别

类指的就是对同一类对象，把所有的属性都封装起来，你也可以把类看成一个高级版的结构体。

【1】定义

class 类名
{
访问权限:
    成员属性;
访问权限:
    成员方法;
}

访问权限：
public:共有的，类内、类外和子类中都可以访问
private:私有的，类内可以访问，类外和子类中都不能访问，类中默认是私有权限
protected:受保护的，类内和子类中可以访问，类外不可以访问(继承再说)

访问权限，是针对于一个类来说的

【2】类和结构体的区别

  1. 类的封装性比结构体更好，类中默认是私有权限，结构体中默认是共有权限
  2. 结构体默认是公有继承，类默认是私有继承
  3. C++中类就是由结构体演变来的
  4. 结构体一般用于实现某种数据结构时，类一般用于描述一类对象的性质

【3】this指针**

每一个类中的非静态成员函数，都有一个this指针，指向调用者，(非静态成员数隐藏 的形参)

谁调用this就指向谁，哪一个类对象调用成员函数，就会用该类对象的首地址，初始化形参this

原型：类类型  *const this； ----->指针的指向不能修改

需要使用this指针的场合

  1. 当形参和成员属性同名
  2. 拷贝赋值函数，需要返回自身的引用
#include <iostream>

using namespace std;
class Rec
{
private:
    int len;
    int wid;
public:
    void set(int l,int w);  //设置长和宽
    void show();   //输出面积和周长
    int get_l();     //获取长和宽
    int get_wid();
};

void Rec::set(int len, int wid)   //r1.set()
{
    this->len = len;
    this->wid = wid;
}

void Rec::show()
{
    cout << "周长:" << (len+wid)*2 << endl;
    cout << "面积:" << len*wid << endl;
}

int Rec::get_l()
{
    return len;
}

int Rec::get_wid()
{
    return wid;
}
int main()
{
    Rec r1;  //r1是一个类对象，实例化了一个类对象r1
    r1.set(9,2);
    Rec r2;
    r2.set(9,2);
    cout << "&r1=" << &r1 << endl;
    return 0;
}

【4】类中的特殊成员函数

特殊的构造函数都是public权限

类中，会默认提供一些特殊的成员函数：构造函数、析构函数、拷贝构造函数、拷贝赋值函数

【5】构造函数

构造函数支持函数重载

构造函数，会在实例化类对象时，系统默认调用无参构造；

如果用户手动定义出了构造函数，系统将不再提供构造函数

类名()
{
   //函数体
}

调用时机

栈区：实例化类对象时，自动调用

堆区：什么时候使用new申请空间，什么时候调用构造函数

当提供构造函数后

ii）构造函数提供了初始化列表的机制

如果在函数体内部，给成员属性赋值，是一个赋值的过程，不是初始化的过程

类名():成员属性1(形参的值1),成员属性2(形参的值)`````

在函数头后面，使用：引出初始化列表，每个成员属性以，分隔，()里面是形参，外面是成员属性

iii）需要使用初始化列表的情况

  1. 形参和成员属性同名
  2. 类中有引用成员时，必须使用初始化列表
#include <iostream>

using namespace std;
class Stu
{
    int age;
    float high;
    int &score;
public:
    //构造函数支持函数重载
    Stu(int age,float high,int a):age(age),high(high),score(a)
    {
        cout << "Stu的有参构造" << endl;
    }
};

int main()
{
    //Stu s;
    int n1 = 90;
    Stu s1(18,9,n1);    //在栈区
    Stu *p;
    //p = new Stu;   //在堆区申请了Stu类对象的空间

    return 0;
}
  1. 类中有const修饰的成员时，必须使用初始化列表
#include <iostream>

using namespace std;
class Stu
{
    int age;
    float high;
    const int score;
public:
//    Stu()
//    {
//        cout << "Stu的无参构造函数" << endl;
//    }
    //构造函数支持函数重载
    Stu(int age,float high,int a):age(age),high(high),score(a)
    {
        cout << "Stu的有参构造" << endl;
    }
};

int main()
{
    //Stu s;
    int n1 = 90;
    Stu s1(18,9,89);    //在栈区
    Stu *p;
    //p = new Stu;   //在堆区申请了Stu类对象的空间

    return 0;
}
  1. 类中含有其他类的子对象时，必须使用初始化列表(类的包含关系)

(如果另一个类只有有参构造需要在初始化列表中宏显性调用，如果另一个类有无参构造，可以不写初始化列表)

                类的包含关系

#include <iostream>

using namespace std;
class Per
{
    string name;
public:
    Per(string name)
    {
        this->name = name;
        cout << "Per的有参构造" << endl;
    }
};

class Stu
{
    int age;
    float high;
    int score;
    Per p1;   //Per类只有有参构造函数
public:
    Stu():p1("zhangsan")
    {
        cout << "Stu的无参构造函数" << endl;
    }
    //构造函数支持函数重载
    Stu(int age,float high,int a,string name):p1(name)
    {
        this->age = age;
        this->high = high;
        this->score = a;
        cout << "Stu的有参构造" << endl;
    }
};

int main()
{
    Stu s;
    int n1 = 90;
    Stu s1(18,9,89,"lisi");    //在栈区

    return 0;
}

【6】析构函数

不支持函数重载

在类对象空间消亡时，系统自动调用

i）格式

~类名()
{
     //函数体
}

ii）调用时机

栈区：对象消亡时，自动调用
堆区：什么时候delete，什么时候调用

构造函数和析构函数调用的时机：

先构造的后析构，后构造的先析构

iii）需要显性写出析构函数的场景

类中有指针成员，并且指针成员，指向堆区的空间

#include <iostream>

using namespace std;
class Stu
{
    string name;
    int *p;
public:
    Stu():p(new int)   //保证指针成员，指向堆区的空间
    {
        cout << "堆区申请的空间为:" << p << endl;
        cout << "Stu的无参构造" << endl;
    }
//    Stu(string name,int p):name(name),p(new int(p))
//    {
//        cout << "Stu的有参构造" << endl;
//    }
    ~Stu()
    {
        cout << "准备释放堆区的空间：" << p << endl;
        delete p;
        cout << "Stu的析构函数" << endl;
    }

};

int main()
{
    Stu s1;
    return 0;
}

【7】拷贝构造函数

利用一个类对象，给另一个类对象初始化时，自动调用拷贝构造函数

如果自己实现了拷贝构造，系统不再提供默认的拷贝构造

i）格式

类名(同类对象的引用)
{
   //函数体
}

ii）使用

#include <iostream>

using namespace std;
class Per
{
    string name;
public:

    //Per中，自己定义了有参构造，系统不再提供无参构造
    Per(string name)
    {
        this->name = name;
        cout << "Per的有参构造" << endl;
    }
    ~Per()
    {
        cout << "Per的析构函数" << endl;
    }
};

class Stu
{
    int age;
    float high;
    int score;
    //Per p1;   //Per类只有有参构造函数
public:
    Stu()
    {
        cout << "Stu的无参构造函数" << endl;
    }
    //构造函数支持函数重载
    Stu(int age,float high)
    {
        this->age = age;
        this->high = high;
        cout << "Stu的有参构造" << endl;
    }

    //拷贝构造
    Stu(Stu &other)
    {
        //this->age = other.age;
        this->high = other.high;
        cout << "拷贝构造函数" << endl;
    }
    ~Stu()
    {
        cout << "Stu的析构函数" << endl;
    }
    void show();
};
void Stu::show()
{
    cout << "age = " << age << endl;
    cout << "high = " << high << endl;
}
int main()
{
    Stu s1(19,100);
    cout << "s1的show:" << endl;
    s1.show();
    Stu s2=s1;
    cout << "s2的show:" << endl;
    s2.show();
    return 0;
}

iii）深浅拷贝问题**

当类中有指针成员，会涉及到深浅拷贝问题

浅拷贝：两个不同类对象的指针成员，指向同一片空间

问题：析构时，会发生二次释放问题；同一片空间被两个不同的类对象占用，发生资源抢占

深拷贝：两个不同类对象的指针成员，指向不同的空间，但是保存的是同样的数据

浅拷贝

深拷贝

#include <iostream>

using namespace std;
class Stu
{
    string name;
    int *p;
public:
    Stu():p(new int)   //保证指针成员，指向堆区的空间
    {
        cout << "堆区申请的空间为:" << p << endl;
        cout << "Stu的无参构造" << endl;
    }
    Stu(string name,int p):name(name),p(new int(p))
    {
    }
    ~Stu()
    {
        cout << "准备释放堆区的空间：" << p << endl;
        delete p;

        cout << "Stu的析构函数" << endl;
    }

    //使用同类其他对象的指针成员解引用后的值，给自己的指针成员的内容初始化
    Stu(Stu &other):name(other.name),p(new int(*(other.p)))
    {
        /*this->name = other.name;
        this->p = new int(*(other.p));*/
        cout << "Stu的拷贝构造" << endl;
    }
    void show();
};
void Stu::show()
{
    cout << "name= " << name << endl;
    cout << "p= " << p << endl;
    cout << "*p= " << *p << endl;
}
int main()
{
    Stu s1("zhangsan",18);
    cout << "s1的show:" << endl;
    s1.show();
    Stu s2 = s1;
    cout << "s2的show:" << endl;
    s2.show();
    return 0;
}

iv）拷贝构造函数的调用时机

  1. 使用已有的类对象，给新的类对象初始化
  2. 函数的参数是一个类对象时，也会调用拷贝构造函数
  3. 函数的返回值是一个类对象时，也会调用拷贝构造函数

测试代码：

#include <iostream>

using namespace std;
class Stu
{
    string name;
public:
    Stu()
    {
        cout << "Stu的无参构造" << endl;
    }
    Stu(Stu &other):name(other.name)
    {
        cout << "Stu的拷贝构造函数" << endl;
    }
    Stu(string name):name(name)
    {
        cout << "Stu的右参构造" << endl;
    }
};

Stu fun(Stu s1)
{
    return s1;
}
int main()
{
    Stu s;
    //Stu s2(fun(s));   //会报错，因为fun(s)的返回值是一个临时值，不能引用
    return 0;
}

【8】拷贝赋值函数 

使用已有的类对象，给另外一个已有的类对象赋值

系统默认提供一个拷贝赋值函数

本质：赋值运算符的重载

i）格式

类名 &operator=(const 类名&other)
{
  //函数体
}

ii)代码

 #include <iostream>

using namespace std;
class Stu
{
    string name;
    int *p;
public:

    //深拷贝赋值函数
    Stu &operator=(const Stu &other)
    {
        name = other.name;
        *p = *(other.p);
        cout << "Stu的拷贝赋值函数" << endl;
        return *this;
    }
    Stu():p(new int)   //保证指针成员，指向堆区的空间
    {
        cout << "堆区申请的空间为:" << p << endl;
        cout << "Stu的无参构造" << endl;
    }
    Stu(string name,int p):name(name),p(new int(p))
    {
    }
    ~Stu()
    {
        cout << "准备释放堆区的空间：" << p << endl;
        delete p;

        cout << "Stu的析构函数" << endl;
    }

    //使用同类其他对象的指针成员解引用后的值，给自己的指针成员的内容初始化
    Stu(Stu &other):name(other.name),p(new int(*(other.p)))
    {
        /*this->name = other.name;
        this->p = new int(*(other.p));*/
        cout << "Stu的拷贝构造" << endl;
    }
    void show();
};
void Stu::show()
{
    cout << "name= " << name << endl;
    cout << "p= " << p << endl;
    cout << "*p= " << *p << endl;
}
int main()
{
    Stu s1("zhangsan",18);
    cout << "s1的show:" << endl;
    s1.show();
    Stu s2;
    s2 = s1;
    cout << "s2的show:" << endl;
    s2.show();
    return 0;
}

【9】匿名对象

没有对象名，通过类名实例化出来的对象，类名();

Stu()；生命周期更短

  1. 全局函数传参
  2. 类数组赋值     //int a=9,b=7,c=8;    int arr[3]={a,b,c};   //int arr[3]={9,7,8};
  3. 临时调用类中的成员函数
  4. 给新的类对象赋值
#include <iostream>

using namespace std;
class Stu
{
    string name;
    int *p;
public:

    //深拷贝赋值函数
    Stu &operator=(const Stu &other)
    {
        name = other.name;
        *p = *(other.p);
        cout << "Stu的拷贝赋值函数" << endl;
        return *this;
    }
    Stu():p(new int)   //保证指针成员，指向堆区的空间
    {
        cout << "堆区申请的空间为:" << p << endl;
        cout << "Stu的无参构造" << endl;
    }
    Stu(string name,int p):name(name),p(new int(p))
    {
    }
    ~Stu()
    {
        cout << "准备释放堆区的空间：" << p << endl;
        delete p;

        cout << "Stu的析构函数" << endl;
    }

    //使用同类其他对象的指针成员解引用后的值，给自己的指针成员的内容初始化
    Stu(const Stu &other):name(other.name),p(new int(*(other.p)))
    {
        /*this->name = other.name;
        this->p = new int(*(other.p));*/
        cout << "Stu的拷贝构造" << endl;
    }
    void show();
};
void Stu::show()
{
    cout << "name= " << name << endl;
    cout << "p= " << p << endl;
    cout << "*p= " << *p << endl;
}

void fun(Stu s1)
{
    cout << "调用成功" << endl;
}
int main()
{
    //1、使用匿名对象用做全局函数传参
    fun(Stu());   //匿名对象的生命周期，只在定义语句的位置，是一个临时值
    
    //2、想要临时使用类中的成员函数
    Stu().show();

    //3、给类对象的数组赋值
    Stu arr[3]={Stu("zhangsan",8),Stu("lisi",19),Stu("xiaoming",20)};

    //4、给新的类对象赋值
    Stu s3(Stu("zhangsan",18));
    return 0;
}

【10】C++中结构体和C的区别以及C++中结构体和类的区别

  1. C中定义需要加struct，C++中可以不加struct
  2. C++中结构体可以有访问权限的控制（public、private、protected）
  3. C++中结构体可以继承
  4. C++中结构体可以封装函数
  5. C++中结构体内可以定义另外一个结构体声明(类型)

结构体和类的区别：

  1. 使用场合不同，类适用于某一类对象属性和方法的封装，结构体用于某种数据结构的实现
  2. 类中默认private，结构体中默认是public
  3. 类默认是私有继承，结构体默认是共有继承
  4. 类的封装性比结构体的封装性更好
笨笨小乌龟11
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
C++ Primer Plus学习（一）—— 基础知识
weixin_41480034的博客
03-13 4593
基础知识预备知识头文件名命名约定名称空间/命名空间C++源代码风格：处理数据变量名位与字节数据类型为何float有效位数为7位初始化整型浮点数相对整型的优缺点转义运算符算术运算符类型转换 最近开始对C++进行系统学习，学习的过程中也会将书上的知识和实践所得进行梳理分享，希望和大家一起学习进步！ 预备知识 C++融合了3种不同的编程方式：C语言（高效、简洁、快速、可移植性）代表的过程性语言，C++在C语言基础上添加的类代表的面向对象语言（OOP-Object Oriented Programming），
C++基础知识篇：C++ 常量
miaozenn的博客
11-21 2286
常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。 常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。 常量就像是常规的变量，只不过常量的值在定义后不能进行修改。 C/C++的学习裙【七一二二八四七零五】，无论你是小白还是进阶者，是想转行还是想入行都可以来了解一起进步一起学习！裙内有开发工具，很多干货和技术资料分享！ 整数常量 整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++基础知识大全
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
C++入门基础知识总结（2022整理）
weixin_55305220的博客
03-23 2万+
一、C++入门基础知识之什么是C++? 1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。 PDF版、C++资料教程、C++电子书籍获取 关注微信公众号：“ C和C加加 ” 回复关键字：“ C++ ”即可领取 二、C++入门基础..
全面总结C++类模板使用的基础知识
微凉秋意的博客
07-03 2885
✨引言 建立一个通用类，类中的成员数据类型可以不具体确定，先用一个虚拟的类型来代表示例： 先使用template关键字声明类模板，接着创建Person类，属性name和age用虚拟类型T1和T2声明，这就是最简单的类模板定义。示例： 可以看到第一行代码T2的后面指定了类型为整型，所以创建类模板对象的时候可以省略T2数据类型的指定，但是切记 ：在不给参数列表最后一个虚拟类型指定数据类型的情况下是无法做到参数列表含有默认参数的。 类模板中的成员
C++基础知识点总结
qq_42868524的博客
08-06 2万+
1.重载函数是否能够通过函数返回值的类型不同来区分？ 不可以。因为在C++编程中，函数的返回值可以忽略（不使用其返回值），程序中调用此时函数名相同和参数相同的两个函数对编译器和程序员来说是没有办法区分的，编译器会提示出错。 2.C++多态机制的实现 (1)重载：同一个类中同一个函数的不同实现，必须保证函数参数不同（类型，个数，顺序），本质上与多态无关。使用重载函数，编译器会根据函数的名称和参...
C++基础知识点整理
hanhan的博客
03-10 6473
基本语法 1、static关键字的作用 1、全局静态变量 加了static关键字的全局变量只能在本文件中使用。 存储在静态存储区，整个程序运行期间都存在。 2、局部静态变量 作用域仍为局部作用域。 不过离开作用域之后，并没有销毁，而是贮存程序中，不能进行访问，除非函数再次被调用。 3、静态函数 只能在声明它的文件中使用，不能被其他文件使用，也不会和其他cpp中的同名函数起冲突。 4、类的静态成员 使用静态成员可以实现多个对象之间的数据共享，也不会破坏隐藏原则。静态数据成员只存储于一处，供所有对象共用。 5.
C++知识黄金学习记录
wyhplus的博客
07-30 1万+
在学习C++之前,我们先来回顾一下C与C++的区别博主认为C和C++的主要区别在于C是面向过程的语言,不支持类和对象;而C++是过程式和面向对象编程语言的结合,因此C++可以被称为混合语言。最开始的C++被称为Cwithclasses，也就是带类的C，这也说明了C++早期设计出来的一个重要目的支持面向对象。C++相比C语言，在面向对象编程上，支持直接声明类，支持声明和自动调用类的构造函数和析构函数，支持权限修饰符，支持类的继承派生等。Person是父类，也称作基类。每日一语https。.........
C++ 基础知识学习 C++ 基础知识.mk
02-24
C++的基础知识是所有C++程序员必须掌握的，这包括但不限于语法、变量、数据类型、运算符、控制结构、函数、类与对象、模板和异常处理。 1. **基本语法**：C++的语法基于C语言，但增加了许多面向对象的特性。它遵循...
C++基础知识学习总结
02-24
总之，C++的基础知识是深入学习和应用C++的基石。通过理解和实践这些概念，可以逐步提升编程技能，进而开发出高效、可靠和可维护的软件系统。无论是初学者还是经验丰富的开发者，不断巩固和深化C++的基础知识都至关...
C++基础课件，讲述C++基础知识
06-20
C++是一种广泛应用于系统软件、应用软件、游戏开发、设备驱动等领域的高级编程语言，它在计算机科学中占据着至关重要的地位。...因此，无论是初学者还是有一定基础的学习者，这个C++基础课件都能提供有价值的指导。
C++基础入门教程（一）：基础知识大杂烩
09-04
C++是一种强大的面向对象编程...掌握这些基础知识是学习C++编程的第一步，也是后续深入学习的关键。随着学习的深入，还将接触到变量、数据类型、控制结构、函数、类等更复杂的概念，这些都将构成C++强大的编程工具箱。
C++基础知识总结
07-25
### C++基础知识总结 #### 一、C++数据和变量的类型及变量作用域 **1. 基本的内置类型** C++提供了一系列基本的内置数据类型，用于存储不同种类的数据。以下是一些常见的类型及其特点： - **布尔型 (`bool`)**：...
hive学习（三）
最新发布
2301_79721847的博客
08-18 128
注：需要注意的是，这里就算直接把txt文件的数据存放到hdfs上表对应的存储目录，那么在select * FROM时也能查出后来添加的数据，因为建表定义存放位置时，实际是指向具体的文件，将文件映射成表结构展示出来。概念：将表的数据分目录存储，存储在不同的文件夹下，然后按照不同的目录查询数据，不需要进行全量扫描，提升查询效率。2）location可以指定（存放在数据存放的具体目录），也可以不指定。注：1）分区字段不能是表中已经存在的字段。2）分区字段可以不止一个，可以设置多个。5.内部表和外部表的区别。
VTK-vtkStructuredGrid学习
weixin_69505365的博客
08-14 392
可以理解为单元格顺序沿着坐标轴排列，但是每个单元格可以不一样。维度理解为X/Y/Z方向的点数，如草图所示分别是4，3，1。此时只提供了12个点，只能构造一层，5.点图、线图、面图如下，对应行的代码改一下出现不同效果图。7.增加Z方向维度，点也要增加，点序保持一致。6.点可以不在同一个平面，随机改变点Z数值。2.获取这些点信息，点顺序要严格按照图示。直接赋值第一层的12个点，改一下Z值。所以Z方向维度是1，不能是其他数据。1.使用CAD随意绘制个网格草图。4.将上面的网格显示出来。
【OCR 学习笔记】二值化——全局阈值方法
TeamLee的博客
08-14 856
该文介绍了图像二值化操作中的全局阈值方法，包括固定阈值方法和Otsu算法（最大类间方差法）。
EmguCV学习笔记 C# 第4章 图像处理
UruseiBest 的技术专栏
08-18 142
版权声明：本文为博主原创文章，转载请在显著位置标明本文出处以及作者网名，未经作者允许不得用于商业目的。教程配套文件及相关说明获得pdf教程和代码。
C++基础知识详解：数据类型与运算
这些知识点构成了C++学习的基础，理解和掌握它们对于编写有效的C++代码至关重要。在实际编程中，还会涉及到类、对象、继承、多态等面向对象的概念，以及模板、异常处理、文件I/O等更高级的主题。对这些知识点的熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笨笨小乌龟11

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值