c++基础学习（07）--（类）

文章目录

  • 目录
    • 类与对象
      • 1.类成员函数
      • 2.类访问修饰符
      • 3.构造函数与析构函数
      • 4.拷贝构造函数
      • 5. 友元函数
      • 6.内联函数
      • 7.this指针
      • 8.指向类的指针
      • 9.类的静态成员

目录

类与对象

在这里插入图片描述
在这里插入图片描述

#include <iostream>using namespace std;class Box
{public:double length;   // 长度double breadth;  // 宽度double height;   // 高度
};int main( )
{Box Box1;        // 声明 Box1，类型为 BoxBox Box2;        // 声明 Box2，类型为 Boxdouble volume = 0.0;     // 用于存储体积// box 1 详述Box1.height = 5.0; Box1.length = 6.0; Box1.breadth = 7.0;// box 2 详述Box2.height = 10.0;Box2.length = 12.0;Box2.breadth = 13.0;// box 1 的体积volume = Box1.height * Box1.length * Box1.breadth;cout << "Box1 的体积：" << volume <<endl;// box 2 的体积volume = Box2.height * Box2.length * Box2.breadth;cout << "Box2 的体积：" << volume <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Box1 的体积：210
Box2 的体积：1560

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问.

在这里插入图片描述

1.类成员函数

在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <limits>using namespace std;class Box{
public://成员变量的定义 double length;double breadth;double height;//成员函数的定义double getVolume(void);void setLength(double len);void setBreadth(double bre);void setHeight(double hei); 
};double Box::getVolume(void){return length*breadth*height;
}
void Box::setLength(double len){length = len;
}
void Box::setBreadth(double bre){breadth = bre;
}
void Box::setHeight(double hei){height = hei;
}int main(){Box Box1;                // 声明 Box1，类型为 BoxBox Box2;                // 声明 Box2，类型为 Boxdouble volume = 0.0;     // 用于存储体积// box 1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// box 2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// box 1 的体积volume = Box1.getVolume();cout << "Box1 的体积：" << volume <<endl;// box 2 的体积volume = Box2.getVolume();cout << "Box2 的体积：" << volume <<endl;return 0;}

当上面的代码被编译和执行时，它会产生下列结果：
Box1 的体积： 210
Box2 的体积： 1560

2.类访问修饰符

在这里插入图片描述
公有成员Public
公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值，如下所示：

#include <iostream>using namespace std;class Line
{public:double length;void setLength( double len );double getLength( void );
};// 成员函数定义
double Line::getLength(void)
{return length ;
}void Line::setLength( double len )
{length = len;
}// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;// 不使用成员函数设置长度line.length = 10.0; // OK: 因为 length 是公有的cout << "Length of line : " << line.length <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Length of line : 6
Length of line : 10

私有成员Private
私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：


class Box
{double width;public:double length;void setWidth( double wid );double getWidth( void );
};

实际操作中，我们一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数，如下所示：

#include <iostream>using namespace std;class Box
{public:double length;void setWidth( double wid );double getWidth( void );private:double width;
};// 成员函数定义
double Box::getWidth(void)
{return width ;
}void Box::setWidth( double wid )
{width = wid;
}// 程序的主函数
int main( )
{Box box;// 不使用成员函数设置长度box.length = 10.0; // OK: 因为 length 是公有的cout << "Length of box : " << box.length <<endl;// 不使用成员函数设置宽度// box.width = 10.0; // Error: 因为 width 是私有的box.setWidth(10.0);  // 使用成员函数设置宽度cout << "Width of box : " << box.getWidth() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Length of box : 10
Width of box : 10

保护成员Protected
保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。
在下一个章节中，您将学习到派生类和继承的知识。现在您可以看到下面的实例中，我们从父类 Box 派生了一个子类 smallBox。
下面的实例与前面的实例类似，在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

#include <iostream>
using namespace std;class Box
{protected:double width;
};class SmallBox:Box // SmallBox 是派生类
{public:void setSmallWidth( double wid );double getSmallWidth( void );
};// 子类的成员函数
double SmallBox::getSmallWidth(void)
{return width ;
}void SmallBox::setSmallWidth( double wid )
{width = wid;
}// 程序的主函数
int main( )
{SmallBox box;// 使用成员函数设置宽度box.setSmallWidth(5.0);cout << "Width of box : "<< box.getSmallWidth() << endl;return 0;
}

在这里插入图片描述

#include<iostream>
#include<assert.h>
using namespace std;class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : public A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员cout << a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。cout << a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;cout << b.a1 << endl;   //正确cout << b.a2 << endl;   //错误，类外不能访问protected成员cout << b.a3 << endl;   //错误，类外不能访问private成员system("pause");return 0;
}

10
1
sh: 1: pause: not found

protected 继承

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : protected A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员。cout << a1 << endl;       //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。cout << a2 << endl;       //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;       //正确。public成员cout << b.a1 << endl;      //错误，protected成员不能在类外访问。cout << b.a2 << endl;      //错误，protected成员不能在类外访问。cout << b.a3 << endl;      //错误，private成员不能在类外访问。system("pause");return 0;
}

private 继承

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : private A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员。cout << a1 << endl;       //正确，基类public成员,在派生类中变成了private,可以被派生类访问。cout << a2 << endl;       //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;       //正确。public成员cout << b.a1 << endl;      //错误，private成员不能在类外访问。cout << b.a2 << endl;      //错误, private成员不能在类外访问。cout << b.a3 << endl;      //错误，private成员不能在类外访问。system("pause");return 0;
}

3.构造函数与析构函数

在这里插入图片描述

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line();  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line(void)
{cout << "Object is being created" << endl;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Object is being created
Length of line : 6

带参数的构造函数
默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(double len);  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line( double len)
{cout << "Object is being created, length = " << len << endl;length = len;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line(10.0);// 获取默认设置的长度cout << "Length of line : " << line.getLength() <<endl;// 再次设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Object is being created, length = 10
Length of line : 10
Length of line : 6
在这里插入图片描述
类的析构函数
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line();   // 这是构造函数声明~Line();  // 这是析构函数声明private:double length;
};// 成员函数定义，包括构造函数
Line::Line(void)
{cout << "Object is being created" << endl;
}
Line::~Line(void)
{cout << "Object is being deleted" << endl;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Object is being created
Length of line : 6
Object is being deleted

4.拷贝构造函数

在这里插入图片描述

#include <iostream>using namespace std;class Line
{public:int getLength( void );Line( int len );             // 简单的构造函数Line( const Line &obj);      // 拷贝构造函数~Line();                     // 析构函数private:int *ptr;
};// 成员函数定义，包括构造函数
Line::Line(int len)
{cout << "调用构造函数" << endl;// 为指针分配内存ptr = new int;*ptr = len;
}Line::Line(const Line &obj)
{cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;ptr = new int;*ptr = *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout << "释放内存" << endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout << "line 大小 : " << obj.getLength() <<endl;
}// 程序的主函数
int main( )
{Line line(10);display(line);return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存

下面的实例对上面的实例稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：

#include <iostream>using namespace std;class Line
{public:int getLength( void );Line( int len );             // 简单的构造函数Line( const Line &obj);      // 拷贝构造函数~Line();                     // 析构函数private:int *ptr;
};// 成员函数定义，包括构造函数
Line::Line(int len)
{cout << "调用构造函数" << endl;// 为指针分配内存ptr = new int;*ptr = len;
}Line::Line(const Line &obj)
{cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;ptr = new int;*ptr = *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout << "释放内存" << endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout << "line 大小 : " << obj.getLength() <<endl;
}// 程序的主函数
int main( )
{Line line1(10);Line line2 = line1; // 这里也调用了拷贝构造函数display(line1);display(line2);return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存
释放内存

在这里插入图片描述

5. 友元函数

在这里插入图片描述

#include <iostream>using namespace std;class Box
{double width;
public:friend void printWidth( Box box );void setWidth( double wid );
};// 成员函数定义
void Box::setWidth( double wid )
{width = wid;
}// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{/* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */cout << "Width of box : " << box.width <<endl;
}// 程序的主函数
int main( )
{Box box;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth( box );return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Width of box : 10
在这里插入图片描述

6.内联函数

在这里插入图片描述

#include <iostream>using namespace std;inline int Max(int x, int y)
{return (x > y)? x : y;
}// 程序的主函数
int main( )
{cout << "Max (20,10): " << Max(20,10) << endl;cout << "Max (0,200): " << Max(0,200) << endl;cout << "Max (100,1010): " << Max(100,1010) << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Max (20,10): 20
Max (0,200): 200
Max (100,1010): 1010
在这里插入图片描述

7.this指针

在这里插入图片描述

#include <iostream>using namespace std;class Box
{public:// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;}double Volume(){return length * breadth * height;}int compare(Box box){return this->Volume() > box.Volume();}private:double length;     // Length of a boxdouble breadth;    // Breadth of a boxdouble height;     // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5);    // Declare box1Box Box2(8.5, 6.0, 2.0);    // Declare box2if(Box1.compare(Box2)){cout << "Box2 is smaller than Box1" <<endl;}else{cout << "Box2 is equal to or larger than Box1" <<endl;}return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1

8.指向类的指针

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。
下面的实例有助于更好地理解指向类的指针的概念：

#include <iostream>using namespace std;class Box
{public:// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;}double Volume(){return length * breadth * height;}private:double length;     // Length of a boxdouble breadth;    // Breadth of a boxdouble height;     // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5);    // Declare box1Box Box2(8.5, 6.0, 2.0);    // Declare box2Box *ptrBox = &Box1;;                // Declare pointer to a class.// 保存第一个对象的地址// 现在尝试使用成员访问运算符来访问成员cout << "Volume of Box1: " << ptrBox->Volume() << endl;// 保存第二个对象的地址ptrBox = &Box2;// 现在尝试使用成员访问运算符来访问成员cout << "Volume of Box2: " << ptrBox->Volume() << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Constructor called.
Constructor called.
Volume of Box1: 5.94
Volume of Box2: 102

9.类的静态成员

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化，如下面的实例所示。
下面的实例有助于更好地理解静态成员数据的概念：

#include <iostream>using namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;// 每次创建对象时增加 1objectCount++;}double Volume(){return length * breadth * height;}private:double length;     // 长度double breadth;    // 宽度double height;     // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount = 0;int main(void)
{Box Box1(3.3, 1.2, 1.5);    // 声明 box1Box Box2(8.5, 6.0, 2.0);    // 声明 box2// 输出对象的总数cout << "Total objects: " << Box::objectCount << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Constructor called.
Constructor called.
Total objects: 2

在这里插入图片描述

#include <iostream>using namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;// 每次创建对象时增加 1objectCount++;}double Volume(){return length * breadth * height;}static int getCount(){return objectCount;}private:double length;     // 长度double breadth;    // 宽度double height;     // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount = 0;int main(void)
{// 在创建对象之前输出对象的总数cout << "Inital Stage Count: " << Box::getCount() << endl;Box Box1(3.3, 1.2, 1.5);    // 声明 box1Box Box2(8.5, 6.0, 2.0);    // 声明 box2// 在创建对象之后输出对象的总数cout << "Final Stage Count: " << Box::getCount() << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：
Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2

静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义，实际上是给静态成员变量分配内存。如果不加定义就会报错，初始化是赋一个初始值，而定义是分配内存。
在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/445461.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

c++基础学习（08）--（继承、重载、多态、虚函数）

c++基础学习（08）--（继承、重载、多态、虚函数）

文章目录目录1.继承2.重载3.多态 && 虚函数目录 1.继承 #include <iostream>using namespace std;// 基类 class Shape {public:void setWidth(int w){width w;}void setHeight(int h){height h;}protected:int width;int height; };// 派生类 class Rectang…
阅读更多...
图的应用

图的应用

1. 图的应用总览 在数据结构中图的应用很广泛&#xff0c;本文主要从以下四个方面介绍&#xff1a; ①最小生成树&#xff1a;给定一个无向网络&#xff0c;在该网的所有生成树中&#xff0c;使得各边权数之和最小的那棵生成树称为该网的最小生成树&#xff0c;也叫最小代价…
阅读更多...
c++基础学习（09）--（数据抽象、数据封装、接口）

c++基础学习（09）--（数据抽象、数据封装、接口）

文章目录目录1.数据抽象2.数据封装3.抽象接口类目录 1.数据抽象 数据抽象&#xff1a;就是把它当做黑箱子使用&#xff0c;内部实现与外部接口分开 C类实现数据抽象&#xff0c;如sort()函数&#xff0c;ostream的cout对象 #include <iostream> using namespace std…
阅读更多...
c++基础学习（10）--（文件、流、异常处理、动态内存、命名空间）

c++基础学习（10）--（文件、流、异常处理、动态内存、命名空间）

文章目录目录1.文件和流2.异常处理3.动态内存4.命名空间目录 1.文件和流 注意 文件打开方式中的in和out都是相对于内存&#xff08;计算机&#xff09;而言的&#xff0c;计算机读取文件&#xff0c;是将数据从磁盘中的文件读入到内存中&#xff0c;所以用的是in #include &…
阅读更多...
数据结构和算法（02）---字符串（c++）

数据结构和算法（02）---字符串（c++）

文章目录目录一.c风格的字符串与操作函数1.c风格字符串2.c风格字符串处理函数二.c中的字符串与操作函数1.c中的string类2.string类的基本操作3.string类的操作汇总目录 数据结构&#xff1a; 逻辑结构&#xff1a;数组&#xff0c;栈&#xff0c;队列&#xff0c;字符串&#x…
阅读更多...
如何学习数据结构和算法——大佬文章汇总

如何学习数据结构和算法——大佬文章汇总

第一篇 第二篇、 作者&#xff1a;左程云 我分别说一下国内和国外的行情。 国内的话&#xff0c;一般来讲&#xff0c;工资高的公司在面试时算法和数据结构题目的比重较大&#xff0c;工资一般的公司比重较小。当然同样公司的不同岗位&#xff0c;要求也会不同&#xff0c;…
阅读更多...
c++基础学习（13）--（STL、标准库）

c++基础学习（13）--（STL、标准库）

文章目录目录1. STL教程2.标准库3.有用的资源目录 1. STL教程 #include <iostream> #include <vector> using namespace std;int main() {// 创建一个向量存储 intvector<int> vec; int i;// 显示 vec 的原始大小cout << "vector size " &…
阅读更多...
哈夫曼实现文件压缩解压缩（c语言）

哈夫曼实现文件压缩解压缩（c语言）

写一个对文件进行压缩和解压缩的程序&#xff0c;功能如下&#xff1a; ① 可以对纯英文文档实现压缩和解压&#xff1b; ② 较好的界面程序运行的说明。 介绍哈夫曼&#xff1a; 效率最高的判别树即为哈夫曼树 在计算机数据处理中&#xff0c;霍夫曼编码使用变长编码表对源…
阅读更多...
c++基础学习（11）--（模板、预处理器、信号处理）

c++基础学习（11）--（模板、预处理器、信号处理）

文章目录目录1.模板2.预处理器3.信号处理目录 1.模板 模板是泛型编程的基础&#xff0c;泛型编程&#xff1a;以一种独立于任何特定类型的方式 #include <iostream> #include <string>using namespace std;template <typename T> inline T const& Max…
阅读更多...
c++基础学习（12）--（多线程、Web编程）

c++基础学习（12）--（多线程、Web编程）

文章目录目录1.多线程2.web编程目录 1.多线程 #include <iostream> // 必须的头文件 #include <pthread.h>using namespace std;#define NUM_THREADS 5// 线程的运行函数 void* say_hello(void* args) {cout << "Hello Runoob&#xff01;" <&…
阅读更多...
《Head First设计模式》第九章（1）迭代器模式

《Head First设计模式》第九章（1）迭代器模式

迭代器模式 因为这一章涉及到两个模式&#xff0c;内容有点多&#xff0c;还有一个组合模式留到下一篇写吧。 有许多种方法可以把对象堆起来成为一个集合&#xff08;collection&#xff09;。你可以把它们放进数组、堆栈、列表或者是散列表&#xff08;Hashtable&#xff09…
阅读更多...
索尼XB950N1 震撼人心的重低音

索尼XB950N1 震撼人心的重低音

虽然题目是震撼人心的重低音&#xff0c;但是低音可以通过app调节&#xff0c;所以我们可以用这个耳机听各种类型的歌曲。 索尼XB950N1与XB950B1非常相似&#xff0c;但索尼XB950N1提供了主动降噪&#xff0c;续航稍长一些。从蓝牙3.0升级到了蓝牙4.1&#xff0c;改善了传输范…
阅读更多...
数据结构和算法（04）---数组，动态内存，vector（c++）

数据结构和算法（04）---数组，动态内存，vector（c++）

文章目录目录数组1.数组的申明2.数组的初始化3.二维数组4.指向数组的指针5.传递数组给函数动态内存1.new &#xff0c;delete运算符2.数组的动态内存分配vector1.vector基本操作2.vector使用3.vector动态二维数组 初始化和赋值目录 数据结构&#xff1a; 逻辑结构&#xff1a;数…
阅读更多...
数据结构和算法（05）---链表（c++）

数据结构和算法（05）---链表（c++）

文章目录目录链表的基本概念1.数组和链表链表的使用1.链表的简单使用2.链表的进阶使用3.链表的高阶使用4.链表的其他操作链表容器list1.list介绍2. list使用3. list与vector之间的区别4.list例子代码目录 数据结构&#xff1a; 逻辑结构&#xff1a;数组&#xff0c;栈&#xf…
阅读更多...
论文阅读 状态压缩

论文阅读 状态压缩

状态压缩 Abstract 信息学发展势头迅猛&#xff0c;信息学奥赛的题目来源遍及各行各业&#xff0c;经常有一些在实际应用中很有价值的问题被引入信息学并得到有效解决。然而有一些问题却被认为很可能不存在有效的(多项式级的)算法&#xff0c;本文以对几个例题的剖析&#xf…
阅读更多...
数据结构和算法（06）---二叉树（c++）

数据结构和算法（06）---二叉树（c++）

文章目录目录二叉树1.二叉树的基本概念2.二叉树的应用和时间复杂度3.二叉树的插入4.二叉树的查找5. 二叉树的遍历6.二叉树的删除二叉树的基本操作1.二叉树的基础操作2.代码实现创建二叉树和三种遍历二叉树的方法目录 数据结构&#xff1a; 逻辑结构&#xff1a;数组&#xff0c…
阅读更多...
如何转载CSDN博客

如何转载CSDN博客

前言 对于喜欢逛CSDN的人来说&#xff0c;看别人的博客确实能够对自己有不小的提高&#xff0c;有时候看到特别好的博客想转载下载&#xff0c;但是不能一个字一个字的敲了&#xff0c;这时候我们就想快速转载别人的博客&#xff0c;把别人的博客移到自己的空间里面&#xff0c…
阅读更多...
CSDN写博客（字体颜色、大小）

CSDN写博客（字体颜色、大小）

markdown里面的标记语言可以使用标签对来实现对文本文字颜色大小信息的控制。下面给出几个实例&#xff1a; 黑体字示例 微软雅黑示例 华文彩云示例 color#00ffff size可以根据实际大小进行设置&#xff0c;一般不超过7。 红色字体CSDN 红色字体CSDN 使用十六进制颜色值 …
阅读更多...
bose qc30 安静的城市是什么样子

bose qc30 安静的城市是什么样子

使用感受 网友1&#xff08;20岁&#xff09;&#xff1a; 当你带着这个耳机听音乐的时候&#xff0c;有一种感觉&#xff0c;感觉这个世界都是你歌曲里的MV&#xff0c;这个枯燥乏味的世界都被赋予了你心中的那份情感&#xff0c;这种感觉&#xff0c;真的很棒 网友2&#…
阅读更多...
DeepLearning.ai 提炼笔记（5-1）-- 循环神经网络

DeepLearning.ai 提炼笔记（5-1）-- 循环神经网络

参考博客 Class 5: 序列模型Sequence Models Week 1: 循环神经网络RNN (Recurrent) 文章目录Class 5: 序列模型Sequence ModelsWeek 1: 循环神经网络RNN (Recurrent)目录序列模型-循环神经网络1.序列模型的应用2.数学符号3.循环神经网络模型传统标准的神经网络循环神经网络的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023