C++_复习Recording

已于 2023-02-21 16:11:26 修改
阅读量879 收藏 6
点赞数 3
分类专栏： C++学习记录 文章标签： c++ 算法 开发语言
于 2023-02-19 18:56:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60479183/article/details/129113293
版权

文章目录

C++复习课

试卷说明：
题型： 填空 + 编程题目

填空题

  1. 构造函数无返回类型，与类名同名;
    复制构造函数用于创建对象，形实参结合，返回和接收对象。
    补充：
    只有在声明语句中使用一个变量初始化另一个对象时才调用复制构造函数！
    案例如下：

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

    1
    反之，则不调用复制构造函数

    int main(void){
	Point p1(1,2),p2;
	p2(p1);
}

    2

  2. 类的继承包含 public,private和protect方式。
    他们的区别是：类成员的访问控制方式不同
    详细差异：

    1. public ：任何外部函数都可以访问公有类型的数据和成员
    2. private: 只允许本类中的函数访问，类外部的任何函数都不能访问
    3. protected: 与private类似，具体表现在继承和派生时对派生类的影响不同

  3. 友元类和友元函数的定义
    友元函数定义如下：

    friend 类型 函数名(形式参数);

    友元类定义如下：

    friend class 类名;  //类名必须是已在程序中定义过的类

  4. 类的静态成员变量: 统计类对象的个数
    类的静态成员函数: 调用静态成员变量 (补充:更完整说法 调用静态成员变量的值并返回)

    补充知识：
    类的静态成员的提出是为了解决同类对象之间的数据共享问题
    思考一下：在统计班级人数总数的case中为什么不可以定义全局变量呢？
    显然，类设计的初衷是为了实现对数据的封装和隐藏，因此若采用全局变量，则无法实现对数据成员的隐藏。因此我们设计了静态成员变量！
    静态成员变量的定义如下：

    static 数据类型 变量名称；

    注意： 静态成员不可以在类中进行赋初值！
    可以通过下面这个简化case来粗略学习一下：

    #include <iostream>
using namespace std;

class StuNum{
    private:
        ...
        static int num; //注意：此处禁止进行赋初值操作
    public:
        ...
}
int StuNum :: num = 0;  //此处进行赋初值，并且赋值格式如左
    
int main(void)
{
    ...
    return 0;
}

  5. 纯虚函数 void f() = 0 构成 抽象类；
    抽象类 可以派生子类，但是不能够创建对象，可以声明类变量。
    补充：
    纯虚函数定义：
    一个虚函数 -> 一个在基类中声明的虚函数 -> 特点：不定义函数体，由其所有派生类根据具体情况来对各自的函数进行实现！
    抽象类因为不可以实例化，因此也不可以作为函数的返回值。
    如果派生类只实现抽象类中的部分纯虚函数，那么它依旧是抽象类；只有当所有纯虚函数均被实现后，其才不是抽象类！

  6. 构造函数的默认形参值
    定义时：从右向左定义;
    调用时：从左向右匹配;

  7. 函数重载的条件有 形参个数 和 类型 以及 const等。

  8. 动态联编和静态联编：
    动态联编是在运行时确定所调用的函数名与操作函数的绑定;
    静态联编是在编译时确定所调用的函数名与操作函数的绑定;

  9. 虚函数：基类中说明了虚函数后，派生类中与其对应的函数可以不必说明为虚函数;
    补充：
    虚函数定义：
    一个非静态成员函数 -> 一个使用保留字virtual声明的非静态成员函数
    定义如下:

    virtual 函数返回类型 函数名(<形参列表>);

    虚函数是实现动态联编的基础！应满足如下三个规则：

    (1) 具有符合类型兼容规则的公有派生类层次结构。
    (2) 在派生类中重新定义基类中的虚函数，对其进行覆盖。
    (3) 通过基类指针或者基类引用访问虚函数。(较为关键且容易疏忽)

  10. 友元机制：破坏类的封装与隐藏，引入友元机制的主要作用？
    作用： 友元提供了在不同类的成员函数之间，类的成员函数与一般函数之间进行数据共享的机制。即可以实现在类的外部访问类的私有成员。
    补充：
    可以理解成友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密。
    友元的正确使用可以提高程序的运行效率，但是破坏了类的封装性和数据的隐蔽性，导致程序的可维护性变差，因此我们应谨慎使用。
    作为一种编程技术手段，友元为我们程序员提供了一种面向对象程序和面向过程程序的相互衔接的接口。从根本上说面向对象的分析与设计方法并不能彻底解决现实生活中的一切需求。许多按照对象化设计的软件系统往往保留一些供早起程序访问的接口，来扩大自身的功能，提高自身的产品竞争能力。
    友元较为实际的应用在于运算符重载，提高了软件系统的灵活性。

  11. C++语言中不能重载的运算符有？
    有5种 如下：

    (1) . (成员访问运算符)
    (2) .* (成员指针访问运算符)
    (3) :: (作用域分辨符)
    (4) sizeof (计算数据大小运算符)
    (5) ? ：(三目运算符)
    补充：
    . 和 .* 提供访问成员的基本功能，禁止重载可以避免混乱！
    :: 和 sizeof 的操作对象是类型,而不是表达式。
    三目运算符本质上是if语句，不值得重载

  12. C++语言中的多态主要包括静态多态和动态多态
    补充：
    常见编译时多态有 函数重载，运算符重载，函数模板
    运行时多态需要使用虚函数来实现

  13. 在重载一个运算符时，如果其参数表中有一个参数，则说明运算符中有几个参数?
    两个
    补充：
    (1) 双目运算符重载为类的成员函数时，函数只显式说明了一个参数，该形参是运算符的右操作数；
    (2) 前置单目运算符重载为类的成员函数时，不需要显示说明参数，即函数没有形参；
    (3) 后置单目运算符重载为类的成员函数时，函数要带有一个整形形参

编程题

题目1：
成员变量：HMS；
构造函数，settime，showtime，计时++，创建对象，调用函数。
定义一个描述时钟的类MyClock，数据成员包括时钟的时、分、秒(int hour；int minute；int second；)，给该时钟类增加合适的成员函数，使得下面的main函数的运行结果：

void main(){
MyClock myClock(23，59，59）；
myClock.ShowTime()；
(myClock++).ShowTime()；
(++myClock).ShowTime()；
}

代码如下：

/*
Main函数操作：
1. 赋初值
2.Showtime
3. ++重载 
*/
#include <iostream>
using namespace std;

class MyClock{
	private:
		int H,M,S;	//hour min sec 
	public:
		MyClock(int h,int m,int s):H(h),M(m),S(s){
			//已由初始化列表完成赋值 
		}
		void SetTime(int h,int m,int s){
			H = h;
			M = m;
			S = s;
		}
		void ShowTime(){
			printf("%02d:%02d:%02d\n",H,M,S);
		} 
		MyClock operator ++();	//前置++参数表为空
		MyClock operator ++(int);	//后置++参数表为int 实际上是哑参数 没有实际意义 
};
/*
函数：重载前置++ 
需要注意进位清零的问题 
*/
MyClock MyClock::operator ++(){
	this -> S++;
	if(S==60){
		this -> M++;
		S = 0;		//进位清零操作 
	} 
	if(M==60){
		this -> H++;
		M = 0;
	} 
	if(H==24){
		H = 0;
	}
	return *this;
}
/*
函数：重载后置++运算符
后置++ 返回的是原来的值  因此需要定义一个变量来保存原来的类对象
故定义old 
*/
MyClock MyClock::operator ++(int){
	MyClock old = *this;
	++(*this);
	//此处应注意：++必须为前置 因为我们上面已经重载过前置++ 故本处可以直接使用即可 
	return old; 
} 
int main(){
	MyClock myClock(23,59,59);
	myClock.ShowTime();
	(myClock++).ShowTime();
	(++myClock).ShowTime();
}

本题目知识补充：

1.运算符重载模板

(1) 重载为类的非成员函数(即友元函数)

//类中声明
friend 返回类型 operator 运算符(<参数表>);
//类外定义
返回类型 operator 运算符(<参数表>);

(2) 重载为类的成员函数

//类中声明
返回类型 operator 运算符(<参数表>);
//类外声明
返回类型 类名::operator 运算符(<参数表>);

以上定义模板的差异其实不难理解，可以参照友元函数和类成员函数的差异即可！
友元函数是类外部函数，自然不需要类名以及作用域分辨符
反之，类内成员函数需要其来加以分辨！

2.this指针

可以试着理解下面这句话：
this指针总是指向其所在成员函数的所在类的对象！
当我们使用this指针时必然是在成员函数中使用，而成员函数必定有其自己的类，而类必须要有对象才能够进行调用成员函数！
这样我相信就可以很容易理解this指针了吧！

题目二
学生类:
成员变量:学号，姓名，学生个数统计count静态变量;
函数:构造函数，复制构造函数，统计count的静态函数;创建对象,调用函数。

#include <iostream>
using namespace std;

class Student{
	private:
		string ID;
		string Name;
		static int count;//切记不可以在这里赋初值
	public:
		Student(){
			cout<<"Student构造函数调用完毕！"<<endl;
		}
		Student(string id,string name):ID(id),Name(name){
			count++;
		} 
		Student(Student &temp){
			ID = temp.ID;
			Name = temp.Name;
			count++;
		}
		~Student(){
			//cout<<"Student析构函数调用完毕！"<<endl;
			count--;
		}
		void show(){
			cout<<Name<<" "<<ID<<endl;
		}
		static void getCount(){
			cout<<"count = "<<count<<endl;
		}
};

int Student::count = 0;

int main(void){
	Student::getCount();
	Student p1("01","czy"),p2(p1);
	p1.show();
	Student::getCount();
	Student p3("02","qwj");
	p3.show();
	Student::getCount();
	return 0;
}

题目三
学生类:
成员变量:学号，姓名char[]，年龄，计算机、网络等多门课成绩
成员函数:构造函数，复制构造函数，使用友元函数统计3个学生的均分。

#include <iostream>
#include <string.h>

using namespace std;

class Student{
	private:
		string ID;
		char * Name;
		int Age;
		double CS;
		double Internet;
	public:
		Student(string id,char *name,int age,int cs,int internet){
			ID = id;
			Name = name;
			Age = age;
			CS = cs;
			Internet = internet;
		}
		Student(Student &temp){
			ID = temp.ID;
			Name = temp.Name;
			Age = temp.Age;
			CS = temp.CS;
			Internet = temp.Internet;
		}
		~Student(){
			
		}
		friend void StuAver_Grade(Student N1,Student N2,Student N3);
};
void StuAver_Grade(Student N1,Student N2,Student N3){
		int Aver_CS = (N1.CS+N2.CS+N3.CS)/3.0;
		int Aver_Internet = (N1.Internet+N2.Internet+N3.Internet)/3.0;
		cout<<"计算机平均分："<<Aver_CS<<endl;
		cout<<"网络平均分："<<Aver_Internet<<endl;
		cout<<"总成绩平均分："<<(Aver_CS+Aver_Internet)/2.0<<endl;
}
int main(void){
	Student p1("01","czy",19,99,100),p2(p1);
	Student p3("03","qwj",20,95,96);
	StuAver_Grade(p1,p2,p3);
	return 0;
}

题目四：
Father类派生son类:
成员函数:构造函数和复制构造函数和析构函数并输出字符串，运行测试。
补充：派生类的构造函数声明一般语法

<派生类名>::<派生类名>(参数总表):基类名1(参数表1),...,基类名m(参数表m),内嵌对象名1(内嵌对象参数表1),...,内嵌对象名2(内嵌对象参数表2)
{
    //派生类新增普通成员的初始化语句
}

代码如下：

#include <iostream>
using namespace std;

class Father{
	private:
		string Name_1;
	public:
		Father(){
			cout<<Name_1<<"类的缺省样式构造函数调用完毕！"<<endl; 
		}
		Father(string name){
			Name_1 = name;
			cout<<Name_1<<"类带参构造函数调用完毕！" <<endl;
		}
		Father(Father &temp){
			Name_1 = temp.Name_1;
			cout<<Name_1<<"类拷贝构造函数调用完毕！" <<endl;
		}
		~Father(){
			cout<<Name_1<<"类析构函数调用完毕！"<<endl;
		}
};
class son:public Father{
	private:
		string Name_2;
		Father father;
	public:
		son(){
			cout<<this<<"Son类的缺省样式构造函数调用完毕！"<<endl; 
		}	
		son(Father temp,string name1,string name2):father(temp),Father(name1){
			Name_2 = name2;
			cout<<"Son类的带参构造函数调用完毕！"<<endl;
		}
		son(son &temp){
			Name_2 = temp.Name_2;
		}
		
		~son(){
			cout<<"Son类的析构函数调用完毕！"<<endl;
		}
};

int main(void){
	Father czy("Father");
	son qwj(czy,"Father","Son");
	return 0;
}

注：自认为本题写的不是很好，疑点很多！后期有时间后会进行修改！
题目5：
定义一个点类与矩形类(组合类)，其中矩形类的成员Point p0表示其左上角坐标，p1是右下角坐标，注意构造函数！
代码如下：

#include <iostream>
using namespace std;

class Point{
	private:
		int x,y;
	public:
		Point(int X,int Y):x(X),y(Y){
			
		}
		Point(Point &temp){
			x = temp.x;
			y = temp.y;
		}
		~Point(){
			
		}
		int getX(){
			return x;
		} 
		int getY(){
			return y;
		}
		void show(){
			cout<<x<<','<<y<<endl;
		}
};
class Rectangle{
	private:
		int Length,Wide;
		Point p0,p1;
	public:
		Rectangle(Point P0,Point P1):p0(P0),p1(P1){
			Length = abs(p1.getX()-p0.getX());
			Wide = abs(p1.getY()-p0.getY());
		}
		~Rectangle(){
			
		}
		void show(){
			cout<<"矩阵的长:"<<Length<<"矩阵的宽:"<<Wide<<endl; 
			cout<<"矩阵面积:"<<Length*Wide<<endl;
		}
};
int main(void){
	Point p0(1,1),p1(2,2);
	Rectangle rec(p0,p1);
	rec.show();
	return 0;
}

题目六
编写-一个抽象类Shape, 在此基础之上派生出类Rectangle(矩形类)和Circle(圆类)， 二者都有计算面积的函数getArea( )和周长的函数getPerim( )。

#include <iostream>
#define PI 3.14

using namespace std;

class Shape{
	public:
		Shape(){
			//构造函数 
		}
		~Shape(){
			//析构函数 
		}	 
		virtual double  getArea() = 0;	//纯虚函数定义 
		virtual double  getPerim() = 0;	//纯虚函数定义 
};
class Circle:public Shape{
	private:
		int r;
	public:
		Circle(int R){
			r = R;
		}
		~Circle(){
			
		}
		double getArea(){
			return PI*r*r;
		}
		double getPerim(){
			return 2*PI*r;
		}
}; 
class Rectangle:public Shape{
	private:
		int x,y;
	public:
		Rectangle(int X,int Y){
			x = X;
			y = Y;
		}
		double getArea(){
			return x*y;
		}
		double getPerim(){
			return 2*(x+y);
		}
};
int main(void){
	Circle c(3);
	Rectangle rec(4,5);
	cout<<c.getArea()<<endl;
	cout<<c.getPerim()<<endl;
	cout<<rec.getArea()<<endl;
	cout<<rec.getPerim()<<endl;
	return 0;
}

题目7
分别定义一组重载函数,计算两个整数、浮点数(float或double)、 复数之和。

#include <iostream>
using namespace std;

//运算符重载->用于计算复数做准备
class Complex{
	private:
		double real,imag;
	public:
		Complex(double r,double i){
			real = r;
			imag = i;
		}
		Complex operator + (const Complex &c){
			Complex t = *this;
			t.real += c.real;
			t.imag += c.imag;
			return t;
		}
		void show(){
			cout<<real<<"i+"<<imag<<'j'<<endl;
		}
};

//函数重载环节
int sum(int a,int b){
	return a+b;
}
float sum(float a,float b){
	return a+b;
}
double sum(double a,double b){
	return a+b;
}
void sum(Complex c1,Complex c2){
	Complex c = c1 + c2;
	c.show();
}

int main(void){
	cout<<sum(1,2)<<endl;
	cout<<sum(1.2,2.4)<<endl<<endl;
	cout<<sum(1.111111,1.111111)<<endl;
	Complex c1(1,2),c2(1,2);
	sum(c1,c2);
	return 0;
}

问题8
港口集团对员工月工资：工资+奖金+小时工资*工作量。
处长工资+奖金=10K+20K；科长工资+奖金=5k+5K；科员工资+奖金=5k+1k。
定义员工抽象类，派生其他类，编写程序求收入。
virtual double 计算工资()=0；纯虚函数姓名[20]；specialty[20]；//专业技能；年龄；工资；小时工资；工作量；职称；奖金；
构造函数、计算工资函数。main测试。

/*
工资 = 基本工资(wage_base) + bonus +  wage_hourly*work_time;
*/
/*注释：
科长： kz_chief
处长： cz_chief
科员： ky_chief 
*/

#include <iostream>
using namespace std;
/*
问题复盘：
起初打算将人员的工资信息和奖金信息放在相应的类中，
但是因为访问权限的问题导致无法访问时薪和工作时间...OK貌似解决了
只需要再申请一个函数空间去计算时薪即可 
问题留待：
其实很想全部都换成public继承，但是基于这是一种带代码陋习...算了  
 
*/
class Employee{
	private:
		string name;
		int age;
		int wage_hourly;
		int work_time;
	public:
		Employee(string Name,int Age,int Wage_hourly,int Work_time){
			name = Name;
			age = Age;
			wage_hourly = Wage_hourly;
			work_time = Work_time;
		}
		virtual double wage_operate() = 0;
		double wage_time(){
			return wage_hourly*work_time;
		} 
};
class kz_chief:public Employee{
	private:
		int kz_wage = 10000;
		int kz_bonus = 20000;
	public:
		kz_chief(string Name,int Age,int Wage_hourly,int Work_time):Employee(Name,Age,Wage_hourly,Work_time){
		
		}
		double wage_operate(){
			return kz_wage + kz_bonus + wage_time();
		}
};
class cz_chief:public Employee{
	private:
		int cz_wage = 5000;
		int cz_bonus = 5000;
	public:
		cz_chief(string Name,int Age,int Wage_hourly,int Work_time):Employee(Name,Age,Wage_hourly,Work_time){
		
		}
		double wage_operate(){
			return cz_wage + cz_bonus + wage_time();
		}
};
class ky_chief:public Employee{
	private:
		int ky_wage = 5000;
		int ky_bonus = 1000;
	public:
		ky_chief(string Name,int Age,int Wage_hourly,int Work_time):Employee(Name,Age,Wage_hourly,Work_time){
		
		}
		double wage_operate(){
			return ky_wage + ky_bonus + wage_time();
		}
};
int main(void)
{
	//读入变量依次为 姓名 年龄 时薪 工作时长 
	kz_chief kz("czy",18,50,8);
	cz_chief cz("qwj",17,40,9);
	ky_chief ky("yll",19,20,10);
	cout<<kz.wage_operate()<<endl;
	cout<<cz.wage_operate()<<endl;
	cout<<ky.wage_operate()<<endl;
	return 0;
}

问题九：
虚基类：A，A派生B1、和B2，B1和B2派生出C
A：ID、name；构造函数等；B1和B2：职称，部门、构造函数等；C：职务级，专业技能、构造函数等；
继承关系如下图所示：
20230220_1

/*
本题目是一个典型的虚继承问题，即继承构成菱形 
*/
#include <iostream>
#include <string.h>

using namespace std;
class A{
	private:
		string ID,Name;
	public:
		A(string id,string name){
			ID = id;
			Name = name;
		}
};
class B1:virtual public A{
	private:
		string title;	//职称 
		string department;	//部门 
	public:
		B1(string id,string name,string Title,string Department):A(id,name),title(Title),department(Department){
			
		} 
		~B1(){
			
		}
}; 
//与B类雷同 
class B2:virtual public A{
	private:
		string title;	//职称 
		string department;	//部门 
	public:
		B2(string id,string name,string Title,string Department):A(id,name),title(Title),department(Department){
				
		} 
		~B2(){
			
		}
}; 
class C:public B1,public B2{
	private:
		string Grade;	//职务等级
		string Skill;
	public:
		C(string id,string name,string Title1,string Department1,string Title2,string Department2,string grade,string skill):A(id,name),B1(id,name,Title1,Department1),B2(id,name,Title2,Department2){
			Grade = grade;
			Skill = skill;
		} 
		~C(){
			
		}
}; 

int main(void){
	//...
	//电脑没电了 不再测试了 
	return 0;
}

补充：
虚基类是什么呢?
实际上，我们看继承图，C继承B1,B2可以很容易看到其继承了两次A
某种意义上这会导致内存的浪费
因此我们提出了虚基类的概念来解决这个问题
问题十：
某小型公司，主要有三类员工(Employee)：
行政人员(AdminStaff)、兼职销售员(Salesman)、经理(Manager)。
行政人员拿固定月薪5000元（静态浮点型常量FS），兼职销售员按该销售员当月销售额的4%提成；
经理既是行政人员，也做销售工作，因此其月薪是固定月薪+销售提成。
运用虚基类+虚函数相关知识，设计抽象类Employee，包含姓名name数据成员（允许用string类）和计算月薪函数float pay()；
然后派生出AdminStaff，增加固定月薪fixedSalary数据成员，实现其pay函数；
派生出Salesman，增加当月销售额sales数据成员，实现其pay函数；
再共同派生出Manager，实现其pay函数。在main中为每个派生类各创建一个对象；
放入Employee类型的指针数组；在for循环中统一处理不同派生类的对象，依次显示每位员工的姓名和工资，并汇总工资总额。

#include <iostream>
using namespace std;

class Employee{
	private:
		string Name;
	public:
		Employee(string name){
			Name = name;
		}
		string getName(){
			return Name;
		}
		virtual float pay() = 0;
};
class AdminStaff:virtual public Employee{
	private:
		float FixedSales = 5000;
	public:
		AdminStaff(string name):Employee(name){
			
		}
		float pay(){
			return FixedSales;
		}
};
class Salesman:virtual public Employee{
	private:
		float Sales;
	public:
	Salesman(string name,float sales):Employee(name){
		Sales = sales;
	}
	float pay(){
		return Sales*0.04;	//销售员工资为销售额的0.04 
	}
};

class Manage:virtual public Employee{
	private:
		float FixedSales = 5000;
		float Sales;
	public:
		Manage(string name,float sales):Employee(name),Sales(sales){
			//
		}
		float pay(){
			return FixedSales+Sales*0.04;	//经理工资 = 固定工资 + 销售额*0.04  
		}
}; 

int main(void)
{
	AdminStaff admin("qwj");
	Salesman salesman("yll",50000);
	Manage manage("czy",50000);
	
	Employee *czy[3] = {&admin,&salesman,&manage};//指针数组 
	
	for(int i=0;i<3;i++){
		cout<<(*czy[i]).getName()<<"的工资为："<<(*czy[i]).pay()<<endl;
	} 
	return 0; 
}

运行结果如下：
20230220

SayYong
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
The_recording_And_Reproduction_Of_Sound
03-20
The_recording_And_Reproduction_Of_Sound
speechprocessing.rar_GUI_GUI matlab_Voice recording GUI_gui 语音处理
07-13
语音处理软件， GUI 界面，本人原创，频域，时域，可以看波形，WINDOW FUNCTION， 录音，
类
m0_51994889的博客
11-02 459
类是面向对象程序设计方法的核心，利用类可以实现对数据的封装和隐蔽。在面向对象程序设计中，程序模块是由类构成的，类是对逻辑上相关的函数与数据的封装，它是对问题的抽象描述。因此集成程度更高，更适合于大型复杂程度的开发。 c++的基本数据类型也远不能满足描述现实世界中各种对象的需要。于是c++提供了对自定义类型的支持，这就是类。可以用自定义类的变量表示“时钟”，“汽车”，“几何图形”或“人”等对象。正如基本数据类型隐含包括了数据和操作，在定义一个类时也要说明数据和操作。 当定义一个类之后，便可以定义该类的变量，.
C++语言--类与对象（一）
COOL_jack的博客
06-23 353
目录类声明公有、私有、保护成员数据抽象和封装内联成员函数内联函数内联函数与带参数宏的区别新的类型转换运算符成员函数的重载及其缺省参数类与结构体隐含的this指针 类声明 公有、私有、保护成员 1.在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。 2.在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。 3.在关键字protected后面声明，与private类似，其差别表现在继承与派生时对派生类的影响不同。 数据抽象和封装 内
C++学习笔记 类的成员函数，数据成员的访问控制，公共，私有，保护。
javasalatu
12-28 343
pubulic： 公有成员：（外部接口） 所有任何外部函数都可以访问公有数据成员和函数成员； private： 私有成员：只允许本类的成员函数可以访问，而类外部的任何函数都不能访问。 紧跟在类声明后面的是private数据成员和函数成员。 protected：和private 类似，但是在派生类中能访问。 protected 成员可以在派上类中使用，但是private只能是...
C-学习笔记整理-函数
weixin_45682081的博客
05-08 325
第四章 类和对象 1.面向对象程序设计的基本特点 ①抽象 抽象是对具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的过程。 先注意问题的本质及描述，其次是实现过程或细节。 数据抽象：描述某类对象的属性或状态（对象相互区别的物理量）。 代码抽象：描述某类对象的共有的行为特征或具有的功能。 抽象的实现：通过类的声明。 //数据抽象： int hour,int minut...
如何使用Perfetto通过trace分析性能问题(四)——Trace Processor
m0_37999066的博客
02-24 1554
Trace processor, perfetto, trace
2018年智能机器人技术综合实训专题一系统基础
zhangrelay的专栏
12-11 2214
2018年智能机器人技术综合实训专题一系统基础 此部分对应教材：《ROS机器人项目开发11例》，采用翻转课堂模式，并未按书中章节顺序授课。 请自学第一章，入门ROS机器人应用程序开发；第四章，使用ROS控制嵌入式电路板；第9章，构建自主移动机器人。 其中大部分内容，在之前课程已经全部讲过了，仿真需要熟练掌握，实际机器人操作安排在第16周进行。 机器人系统设计基础涵盖内容非常广，应用也非常丰...
ROS(1和2)机器人操作系统相关书籍、资料和学习路径
热门推荐
zhangrelay的专栏
10-09 2万+
ROS机器人相关书籍与资料（更新日期2017年11月） ROS发展10年了，已经逐渐成为通用的机器人操作系统标准。ROS 2相关资料链接：http://blog.csdn.net/zhangrelay/article/details/78778590。 之前写过一篇博文总结过相关书籍（流行版本和相关书籍汇总），但是并没有具体介绍。 学习ROS基础知识以官网和书籍为主，如果需要了解ROS最新成...
《精通QTP——自动化测试技术领航》—第1章1.3节录制与回放—QTP的开关
weixin_34360651的博客
05-02 313
本节书摘来自异步社区《精通QTP——自动化测试技术领航》一书中的第1章1.3节录制与回放—QTP的开关，作者余杰 , 赵旭斌，更多章节内容可以访问云栖社区“异步社区”公众号查看。 1.3　录制与回放—QTP的开关精通QTP——自动化测试技术领航阶段要点 录制在实际项目应用中的价值观（极低）。 新手切记不可在项目应用时被禁锢在录制中。 录制及其相关功能的重...
Android NDK 直播推流与引流
2401_84415615的博客
04-29 389
音视频数据编码和推流在 Native 层实现，首先添加 faac ， x264 ， librtmp 第三方库到 AS 工程，然后初始化相关设置，基于生产者与消费者模式，将编码后的音视频数据，在生产者线程中打包 RTMPPacket 放入双向链表，在消费者线程中从链表中取 RTMPPacket ，通过 RTMP\_SendPacket 方法发送给服务器。整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
lf.rar_matlab 项目_voice recording
09-19
基于tms5402芯片的语音录放程序 有项目工程和程序
recording-网页录音_recording_
09-30
网页录音插件，用户在html页面中点击
TXRX-Data-Software.zip_Visual_C++_
08-12
this is the utillities for recording the serial port. and it saves the data into file.
C的I/O操作
weidl001的博客
06-17 735
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C/C++ 提取DNS请求/响应数据包之中的 Quesion 内容
liulilittle的博客
06-20 240
它主要是提取DNS数据包之中查询问题的信息，如：问题类型、问题类别、问题内容（域/IP），我们如果想要对于某个DNS数据包需要进行遥测的时，或者进行NS缓存生命周期管理，那么就需要类似这样的函数实现了。
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 541
LeetCode 算法：排序链表 c++
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 340
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
start_recording
06-13
`start_recording`通常是一个命令或函数，用于开始录制音频或视频。这个术语在不同的软件和应用中可能会有不同的含义，比如在录音应用中，它可能用于启动录音功能；在某些视频会议工具中，可能是开始录制会议的快捷...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值