C++笔记：类和对象(一)-＞封装

已于 2024-04-24 16:04:46 修改
阅读量747 收藏 12
点赞数 21
分类专栏： C++基础知识 文章标签： 笔记
于 2024-04-16 19:44:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58240849/article/details/137831741
版权

类和对象

        认识类和对象

         先来回忆一下C语言中的类型和变量，类型就像是定义了数据的规则，而变量则是根据这些规则来实际存储数据的容器。类是我们自己定义的一种数据类型，而对象则是这种数据类型的一个具体实例。类就可以理解为类型，而对象就可以理解为变量，而且对象是更加高级的变量。

        类型 = 类型数据 + 类型操作

        比如double类型

        他的数据类型占用8字节，并且可以表示成小数。

        类型操作可以加减乘除，但是它不支持模(%)运算。

        那么类就是包含了类型数据和类型操作的一个集合。

        也可以理解为数据就是类的属性，操作就是类的行为

        通过下面我定义的一个人的类，那么height,sex, age都是这个类的类型数据，而类型操作就是函数run和函数speak。

class People {
    double height;//身高
    char sex;//性别
    int age;//年龄
    string name;//姓名
    void run() {//跑
        cout << "I can run" << endl;
    }
    void speak() {//说话
        cout << "I can speak" << endl;
    }
};

        那么我需要一个特定的人的时候，我就需要定义一个对象用来存这个特定人的属性。

        下面的用类定义一个对象，并且对他的属性进行赋值。

People a;
a.name = "Zhang san";
a.age = 18;
a.sex = '1';//女0，男1
a.height = 1.89;

        而我需要这个人进行说话或者跑时，就需要调用他相应的操作，也就是函数。

a.run();
a.speak();

        访问权限

        public：是公共的资源，是谁都可以访问的资源，比如空气，阳光，公共场合都是谁都可以访问进行使用的。

        private：是私有的资源，是只能类自己进行访问的资源，比如每个人自己的私人物品，是只能自己使用和访问的。

        protected：是受保护的资源，是只能自己访问以及自己的子类访问的资源，比如你儿子可以使用你的东西。(在后续文章继承时会用到protected权限)

        friendly：是在关键字friend声明后，它允许被声明后的类或函数访问这一个类的私有或受保护的资源，比如你的好兄弟在你的允许下可以访问和使用你的私人物品。(在后续的文章中会更新到使用)

        重点：这里的访问权限是规定的类外对该类类内的访问权限。

        比如我在一个类中定义了一个访问权限为私有的方法，那么我只能在这个类的内部进行调用，在类外是无法调用的，除非我对这个方向进行了friend友元声明。

        对于为什么要为什么要有访问权限的设置，看如下代码：

#include<iostream>
using namespace std;


class People {
public :
int age;
    void speak() {
        cout << "my age is "<< age << endl;
        return ;
    }
};


int main() {
    People a;
    a.age = -100;
    a.speak();
    return 0;
}

        如果对于age是public公有访问的，那么在设置年龄的将不会受到限制，对于这份代码可能没有问题，如果在以后设计项目或者工程时，就会造成灾难性的错误。

        那么正确的写法应该如下，把age设置为私有的，对age赋值时，定义一个函数来进行对age赋值，并判断值是否在正确范围内，对于获取age值也定义一个函数进行来获取。

#include<iostream>
using namespace std;


class People {
public :
    void speak() {
        cout << "my age is "<< age << endl;
        return ;
    }
    void set_age(int x) {
        if (age <= 0 || age > 1000) {
            perror("your age is error\n");
            exit(1);
        }
        age = x;
        return ;
    }
    int get_age() {
        return age;
    }
private :
    int age;
};


int main() {
    People a;
    a.set_age(-100);
    a.speak();
    return 0;
}

构造函数和析构函数

        定义一个对象的流程：

     对于构造函数的详细解析如下代码：

#include<iostream>
using namespace std;

class A {
public :
    A() {//默认构造函数
        cout << "default constructor" << endl;
    }
    //如果这里没有const关键字,传入的对象是const声明的那么就会报错
    //如果没有&(引用),那么将会造成无限套娃的拷贝构造
    //假如这里没有&，那么这里的形参就相当于实参给他赋值
    //而赋值就是 A a = b, b是实参传入的值
    //那这里就会又调用构造函数,形成无限套娃
    A(const A &a) {
        this->x = a.x;
        this->y = a.y;
        cout << "copy constructor" << endl;
    }
    A(int x, int y) {//有参构造函数
        cout << "have parameter constructor" << endl;
        this->x = x;//this表示当前对象的地址
        this->y = y;
    }
    void operator=(const A &a) {//这个函数是=运算符重载，是类中默认有的
        cout << "this is assigment"  << endl;
        return ;
    }
    A(int x) {//转换构造函数
        cout << "conversion constructor" << endl;
        this->x = x;
        this->y = 0;
    }
    void output() {
        cout << "(" << x << ", " << y << ")" << endl;
    }
    ~A() {//析构函数
        cout << "destructor" << endl;
    }
private :
    int x, y;
};


void func(A a) {
    cout << "func : ";
    a.output();
    return ;
}


int main() {
    A a;//调用默认构造函数
    cout << "1-------------------------" << endl;
    A b(1, 2);//调用有参构造
    cout << "2-------------------------" << endl;
    //这里就调用了拷贝构造函数
    A e = b;
    cout << "3-------------------------" << endl;
    //这里只是运用了普通赋值运算符
    //通过执行会发现没有执行任何构造函数
    a = b;
    cout << "4-------------------------" << endl;
    //调用转换构造，将int类型转换为A类型
    //这里也可以是另一个类型的对象，那也是转换构造
    //不过还需要从新定义一个需要转换构造的函数,里面的参数就是对应的类型
    A c(3);
    cout << "5-------------------------" << endl;
    //这里调用的是拷贝构造函数，将对象b进行拷贝给函数形参a
    func(b);
    func(c);
    cout << "6-------------------------" << endl;
    //对于这中函数调用情况
    //这里就会用到转换构造
    //他会隐式的将int类型5通过转换构造转会为A类型
    func(5);
    cout << "7-------------------------" << endl;
    //这里相当于A d(4);
    //这里可以这样理解
    //等号类型相同编程才能通过
    //那么4，int类型就会通过转换构造变成A类型
    //如果没有转换构造那么就编译无法通过
    A d = 4;
    a = 6;
    cout << "8-------------------------" << endl;
    return 0;
}

构造函数的初始化列表

构造函数中的初始列表使用：

#include<iostream>
using namespace std;

class C {
public:
    C(int n) {
        this->num = n;
        cout << "C coversion constructor" << endl;
    }
    void output() {
        cout << num;
    }
private :
    int num;
};

class A {
public :
    //:后面是构造函数的初始化列表
    A(int a) : a(a), b(10), c(6) {
        cout << "A constructor" << endl;
    }
    void output() {
        cout << " " <<a << " " << b << " ";
        c.output();
        cout << endl;
        return ;
    }
private :
    int a, b;
    C c;
};


int main() {
    A a(2);
    a.output();
    return 0;
}

构造函数和析构函数的调用顺序

如下这份代码：

#include <iostream>
#include <string>
using namespace std;


class A {
public :
    A() {};
    A(string n)  {
        name = n;
        cout << name << " class A construtor" << endl;
    }
    ~A() {
        cout << name << " class A destructor" << endl;
    }
int *p;
private :
    string name;
};

class B {
public :
    //:a(a)
    //:后面是构造函数时，最该对象中的成员属性进行初始化操作
    B(string n, A &a) : a(a){
        name = n;
        cout << name << " class B construtor" << endl;
        //new关键字可以理解为，C语言中malloc去堆区中开辟一段空间
        a.p = new int[10];
        return ;
    }
    A &a;//创建一个引用属性，这里&a可以暂时理解为取a的地址
    ~B() {
        //delete就相当于C语言中的free对开辟空间的释放
        delete a.p;
        cout << name << " class B destructor" << endl;
    }
private :
    string name;
};


int main() {
    A a("a");
    B b("b", a);
    return 0;
}

执行结果：

        可以发现，析构顺序是构造顺序反过来的，通过代码可以发现在B中的有参构造中用到了a对象的引用，然后对a对象的p指针开辟了一段空间，如果析构时顺序和构造顺序一样的那么，在析构b对象时，去delete a.p去释放开辟的空间时，a对象已经被析构掉了，那就也无法去找a对象中的指针p了。

类属性与方法 

        对于上面的代码的类中，它们只有成员属性和成员方法。

        就拿文章中的第一份代码来看，对于属性，也就是类中的变量，他所存储的值是跟着对象改变而改变的，而类中的两个方法(函数)，也是随着对象改变而改变的，因为它们的输出也是不同的。所以这些叫做成员属性和成员方法。

class People {
    double height;//身高
    char sex;//性别
    int age;//年龄
    string name;//姓名
    void run() {//跑
        cout << name << " can run" << endl;
    }
    void speak() {//说话
        cout << name << " can speak" << endl;
    }
};

 下面这份代码是对成员属性和成员方法的使用：

#include<iostream>
using namespace std;


class Point {
    public :

    Point() : x(0), y(0) {} //默认构造
    //区分x和y
    //在x(x),括号外是成员属性x,括号内是形参x
    Point(int x, int y) : x(x), y(y) {} //有参构造
    void set_x (int x) { this->x = x; }
    void set_y (int y) { this->y = y; }
    int get_x() { 
        //访问类中的类属性
        Point::get_x_cnt += 1;
        return this->x; 
    }
    int get_y() { return this->y; }
    //这里是直接定义了类方法
    static int x_cnt() {
        return Point::get_x_cnt;
    }
    private :
    //这里只是声明了这个变量
    //get_x_cnt,记录变量x在被get时,在整个程序执行时被调用了多少次
    static int get_x_cnt;
    int x, y;
};

//这里就是定义了get_x_cnt, 并且给他的值进行了初始化
int Point::get_x_cnt = 0;



int main() {
    Point p1(3, 4), p2(5, 6);
    cout << p1.get_x() << ", " << p1.get_y() << endl;
    cout << p2.get_x() << ", " << p2.get_y() << endl;
    p1.get_x();
    p1.get_x();
    p1.get_x();
    cout << "x_cnt : " << Point::x_cnt() << endl;
    return 0;
}

 const 方法

对于const和mutable关键字使用，对于上一份代码的修改：

#include<iostream>
using namespace std;


class Point {
    public :
    Point() : x(0), y(0) , get_x_cnt(0){} //默认构造
    Point(int x, int y) : x(x), y(y), get_x_cnt(0) {} //有参构造
    void set_x (int x) { this->x = x; }
    void set_y (int y) { this->y = y; }
    int get_x() const { //修改处
        get_x_cnt += 1;
        return this->x; 
    }
    int get_y() const { return this->y; }//修改处
    int x_cnt() const {//修改处
        return get_x_cnt;
    }
    private :
    //现在get_x_cnt，表示当前对象对get_x函数的调用次数
    //mutable关键字表示不收const关键之的限制
    //所以就算有const关键字，那么mutable声明的变量也可以进行修改
    mutable int get_x_cnt;
    int x, y;
};




int main() {
    const Point p(10, 15), p2(1, 2);
    cout << p.get_x() << ", " << p.get_y() << endl;
    p2.get_x();
    p2.get_x();
    cout << "p1 : get_x_cnt = " << p.x_cnt() << endl;
    cout << "p2 : get_x_cnt = " << p2.x_cnt() << endl;
    return 0;
}

类的声明和定义

还是对类属性和类方法的那份代码进行修改：

#include<iostream>
using namespace std;

//在类中只放方法的声明
class Point {
    public :
    Point();
    Point(int x, int y);
    void set_x (int x);
    void set_y (int y);
    int get_x() const;
    int get_y() const;
    static int x_cnt();
    private :
    static int get_x_cnt;
    int x, y;
};

//对于类中的方法进行实现
//那么就可以将这两部分拆开
//定义放在源文件中，声明放在头文件中
Point::Point() : x(0), y(0) {}
Point::Point(int x, int y) : x(x), y(y) {}
void Point::set_x(int x) {
    this->x = x; 
}

void Point::set_y(int y) {
    this->y = y; 
}

int Point::get_x() const{
    Point::get_x_cnt += 1;
    return x; 
}

int Point::get_y() const{
    return y;
}

int Point::x_cnt() {
    return Point::get_x_cnt; 
}

int Point::get_x_cnt = 0;

int main() {
    Point p1(3, 4), p2(5, 6);
    cout << p1.get_x() << ", " << p1.get_y() << endl;
    cout << p2.get_x() << ", " << p2.get_y() << endl;
    p1.get_x();
    p1.get_x();
    p1.get_x();
    cout << "x_cnt : " << Point::x_cnt() << endl;
    return 0;
}

default和delete关键字

    delete和default关键字引用代码：

#include<iostream>
using namespace std;

class A {
public :
    //A() = delete;
    A() {
        cout << "default constructor" << endl;
    }
    A(int n) : x(n) {
        cout << "conversion constructor" << endl;
    }
    A(const A &) {
        cout << "copy constructor" << endl;
    }
private :
    int x;
};

class B {
public :
    B() = default;
    B(const B&) = default;
private :
    A a1, a2, a3;
};

class C {
public :
    C() = default;
    //C(const C&) {}//这种情况叫撒比构造
    C(const C&) = default;
private :
    A a1, a2, a3;
};

class Point {
public :
    Point() = default;//请求编译器生成默认构造函数
    Point(int x, int y) : x(x), y(y) , p(new int(5)), a(1){}
    //Point(const Point &) = delete;//删除编译器的拷贝构造函数
    //Point(const Point &) = default;//拷贝函数生成默认行为,在使用这个拷贝构造函数时就会造成双重释放的报错
    //这就是深拷贝
    Point(const Point &a) : x(a.x + 1), y(a.y + 2), a(a.a){
        //如果这里成员属性a直接用这样去赋值拷贝
        //那么成员属性a就会使用A类的默认构造函数进行构造
        //而A类的默认构造函数已经被删除了，那么就会报错
        //this->a = a.a;
        this->p = new int;
        *(this->p) = *(a.p);
    }
    ~Point() {
        delete p;
    }
private :
    A a;
    int *p;
    int x, y;
};


int main() {
    Point p1(1, 2), p2 = p1;
    return 0;
}

 对象和引用

        

代码演示：

#include<iostream>
using namespace std;

class A {
public :
    A() = default;
    A(const A&) = default;
private :

};

class B {
public :
    B(A &a) : a(a) {}
private :
    A &a;
};

class C {
public :
    C()  = default;
    C(const C &) = default;
    static void destroy(C *c) {
        delete c; 
        return ;
    }
private :
    ~C() {}
};

int main() {
    A a;
    B b(a);
    C *c = new C();
    C::destroy(c);
    return 0;
}

返回值优化

先回顾一下一个对象是如何进行创建的：

如下代码：

#include<iostream>
using namespace std;

class A {
public :
    A() {
        cout << this << " default constructor" << endl;
    }
    A(const A &) {
        cout << this << " copy constructor" << endl;
    }
    string s;
};

A func() {
    //这里创建temp调用了默认构造
    A temp;
    cout << "temp = " << &temp << endl;
    temp.s = "hello func";
    //return这里会有一个匿名对象
    //然后temp会通过拷贝构造拷贝给这个匿名对象
    return temp;
}

int main() {
    //然后这里的a通过拷贝构造，拷贝这个匿名对象
    //那么创建a对象最终会调用
    //一次默认构造，两次拷贝构造对吧
    A a = func();
    cout << "a = " << &a << endl;
    return 0;
}

执行结果：

会发现结果只调用了一次默认构造，也就是在调用func函数时创建temp进行调用的默认构造，这就就是编译器进行了返回值优化，可以看到对象a的地址和对象的temp的地址一摸一样都没变，说明中间的这些拷贝过程就是浪费资源。

那么我在编译时关闭了，返回值优化，再看结果

和我对于代码的分析是一样的。

总结：

        对于上面的内容，只是我们在程序设计时需要掌握的知识点，应为没有掌握这些知识点，你也无法去实现你对应思想的代码。

        最后来说一下封装，这篇文章最主要的内容就是封装一个类，在下一篇文章C++类中的重载也是封装的一部分。而封装是什么，在设计代码的过程中，我们回去思考一个类他应该有什么属性，什么行为，然后我们就可以将这些属性和行为封装成为一个类。 对象是在程序运行中主要的逻辑，而类就是用来将对象进行分类的。不同的对象对于不同的类，就有不同的属性和行为，而这种代码设计逻辑就是封装。

        总的来说对于封装，可以理解为现实世界中的人和其他物种，我们具体的每个人就是对象，而人就想当于类，而类就去定义了我们的属性和行为，而不同的人有不同的行为和属性，那就是对象。人类就相当于封装了我们的属性和行为。所以在设计一个类去封装时我们需要考虑的就是他有什么属性，什么行为。

下个内容：C++笔记：C++中的重载

初猿°
关注
  • 21
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深入探索C++对象模型-总结笔记.pdf
07-25
本书专注于C++面向对象程序设计的底层机制，包括结构式语意、临时性对象的生成、封装、继承，以及虚拟——虚拟函数和虚拟继承。这本书让你知道：一旦你能够了解底层实现模型，你的程序代码将获得多么大的效率。...
C++核心编程：P13-＞模板----类模板
InnerPeaceHQ的博客
07-12 3237
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象----封装 C++核心编程：P5-＞类和对象----对象的初始化和清理 C++核心编程：P6-＞类和对象----C++对象模型和this指针 C++核心编程：P7-＞类和对象----友元 C++核心编程：P8-＞类和对象----运算符重载 C++核心编程：P9-＞类和对象----继承 C++核心编程：P10
C++入门指南：类和对象总结笔记（中）
Zhenyu_Coder的博客
10-04 3909
而_t是Time类对对象，在对d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
C++核心编程：P11-＞文件操作
InnerPeaceHQ的博客
06-15 659
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象----封装 C++核心编程：P5-＞类和对象----对象的初始化和清理 C++核心编程：P6-＞类和对象----C++对象模型和this指针 C++核心编程：P7-＞类和对象----友元 C++核心编程：P8-＞类和对象----运算符重载 C++核心编程：P9-＞类和对象----继承 C++核心编程：P10
C++核心编程：P12-＞模板----函数模板
InnerPeaceHQ的博客
07-03 504
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象----封装 C++核心编程：P5-＞类和对象----对象的初始化和清理 C++核心编程：P6-＞类和对象----C++对象模型和this指针 C++核心编程：P7-＞类和对象----友元 C++核心编程：P8-＞类和对象----运算符重载 C++核心编程：P9-＞类和对象----继承 C++核心编程：P10
黑马程序员C++笔记---类和对象
m0_72566333的博客
07-22 1437
黑马程序员C++笔记---类和对象基本知识
C++学习笔记- 面向对象 .md
11-13
内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联函数，this指针，静态成员...
JAVA面向对象基础入门笔记（对比C++）
12-21
因为C++并不是一个有严格意义的面向对象的语言，它有过程和对象的共同特点，既可以当作C语言来实现面向过程，也可以像JAVA那样封装各种类来实现特点功能的面向对象编程。 简单介绍了一下JAVA的类，主要对有C/C++基础...
numpy-boost:允许在 C++ 中作为 boost 访问 Numpy 数组的包装器
06-20
这段代码为数组提供了一个非常薄的包装器，使它们可以在 C++ 中作为对象进行访问。 在可能的情况下，不会复制数据本身，即使数据不连续也是如此。 使用原始 Numpy/C API 的优点是： 不使用宏的更简洁的语法，例如...
c++类的入门笔记.md
10-07
类的封装继承多态学习笔记，附有代码案例-typora软件格式
python学习笔记----循环语句（四）
取个名字太难了a的博客
04-28 968
随机数种子在生成随机数的过程中起到一个非常重要的作用。它是用于初始化随机数生成算法（伪随机数生成器）的初始值。随机数种子的作用可重复性：当你使用特定的种子值初始化随机数生成器时，即使在不同的运行环境或不同时间，生成的随机数序列都将是相同的。这对于调试和测试非常重要，因为它允许程序的行为在使用随机数时保持一致。控制随机性：种子提供了一种方法来控制随机数生成过程。通过改变种子，你可以获得不同的随机数序列，这对于模拟和其他需要随机输入的应用非常有用。
Spring Cloud学习笔记（Hystrix）：execute，queue，observe，toObservable样例和特性
sinat_38393872的博客
04-29 676
这是本人学习的总结，主要学习资料如下马士兵教育。
Build a Large Language Model (From Scratch) 从头开始构建大型语言模型(第二章)学习笔记
Czi.的博客
04-29 1017
LLM需要将文本数据转换为数值向量，称为嵌入，因为它们无法处理原始文本。嵌入将离散数据（如单词或图像）转换为连续向量空间，使它们与神经网络操作兼容。第一步，将原始文本分解为tokens，这些tokens可以是单词或字符。然后，tokens被转换为整数表示形式，称为token IDs。可以添加特殊tokens（例如和）来增强模型的理解并处理各种上下文，例如未知单词或标记(marking)不相关文本之间的边界。
公文写作笔记
332295505的博客
04-29 191
最后一行的日期，后边占4个格子。落款单位在日期的正上方。③结尾：简单的总结（字数紧张时，可以省略）②主题：对策（别人做得好，就借鉴）
python学习笔记----函数进阶（七）
取个名字太难了a的博客
05-01 446
假设我们正在编写一个购物应用，需要根据不同的促销策略来计算商品的最终价格。我们可以定义几种不同的促销计算函数，然后将这些函数作为参数传递给另一个函数，这个函数负责应用这些促销策略来显示最终价格。
Pytorch学习笔记——环境配置安装
weixin_50765519的博客
04-29 298
Anacodna必备（工具包里面都包含的有，集成与运用科学分析的软件，比较方便）安装完成，点击所示位置，出现(base)..表示安装成功。
集成学习算法学习笔记
m0_46521579的博客
04-27 489
三个臭皮匠顶一个诸葛亮集成学习会考虑多个评估器的建模结果，汇总后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。很多独立的机器学习算法：决策树、神经网络、支持向量机集成学习构建了一组基学习器，并将它们综合起来作为最终的模型。在很多集成学习模型中，对基学习器的要求很低。集成学习适用于机器学习的几乎所有领域：回归、分类、推荐和排序。相同的多个基学习器不会带来任何提升，不同的模型取长补短，每个基学习器都会犯不同的错误，综合起来犯错的可能性不大。
python学习笔记B-13：序列结构之元组--元组的相关操作
datouhaiyu的博客
04-30 254
元组的常用相关操作有：获取最大值、获取最小值、获取元组长度、查询是否包好某元素、获取元素索引值、获取元素数量。
领域驱动设计（DDD）笔记（一）基本概念
最新发布
ysf465639310的专栏
05-03 738
DDD是一种面向复杂需求的软件设计方法，在各大佬口中广泛提及但很少落地，基于代码工程角度我抛砖引玉，整理出我的认识
生成一个c++理论笔记
05-28
好的，以下是一份简要的C++理论笔记： C++是一种高级编程语言，它既支持面向过程的程序设计，又支持面向对象的程序设计。 C++的基本语法使用类似于C语言的语法，但是它增加了许多新的特性，例如：类、对象、继承、多态等。 C++的程序结构由头文件、全局变量、函数和类组成。头文件用于声明类、函数和全局变量，函数是C++程序的基本组成单元，类是C++特有的一种语法结构，用于封装数据和功能，实现面向对象的程序设计。 C++的重要特性包括： 1. 封装：将数据和操作封装在一起，防止外界直接访问和修改数据，确保数据的安全性。 2. 继承：可以从一个已有的类派生出新的类，新的类继承了原有类的所有特性，同时还可以添加新的特性。 3. 多态：同一个函数可以根据传入参数的不同，有不同的行为表现，提高了程序的灵活性和可扩展性。 4. 模板：可以使用模板来编写通用的函数和类，可以根据不同的数据类型，生成不同的代码。 C++的标准库提供了许多常用的数据类型和函数，例如：字符串、向量、迭代器、算法等。 C++的开发工具有很多，例如：Visual Studio、Code::Blocks、Eclipse等，可以根据自己的需要选择合适的开发工具。 以上是一份简要的C++理论笔记，希望对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

初猿°

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

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

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

打赏作者

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

抵扣说明：

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

余额充值