c++学习笔记4

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量115 收藏 1
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870790/article/details/104032460
版权

类和对象

封装

简单的类示例
#include<iostream>
using namespace std;

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长
//圆求周长的公式：2*PI*半径

//class 代表要设计一个类，类后面紧跟着的就是类的名称
class Circle {
	//访问权限
public:
	//属性
	//半径
	int m_r;

	//行为
	//获取圆的周长
	double calculateZC() {
		return 2 * PI * m_r;
	}
};

int main() {

	//通过圆类 创建具体的圆（对象）
	Circle cl;
	//给圆对象 的属性进行赋值
	cl.m_r = 10;

	cout << "圆的周长：" << cl.calculateZC() << endl;
	system("pause");
	return 0;
}
学生类示例

添加set 方法

#include<iostream>

using namespace std;
//学生类
class Student {
public:
	string m_Name;
	int m_Id;

	void showStudent() {
		cout << "姓名：" << m_Name << "  学号：" << m_Id << endl;
	}

	void setName(string name) {
		m_Name = name;
	}

	void setId(int id) {
		m_Id = id;
	}

};
int main() {

	//创建一个学生对象
	Student s1;
	//s1.m_Name = "张三";
	s1.setName("张三");
	//s1.m_Id = 1;
	s1.setId(8);
	s1.showStudent();

	Student s2;
	s2.m_Name = "李四";
	s2.m_Id = 2;
	s2.showStudent();

	system("pause");
	return 0;
}
访问权限

public
protected
private

#include<iostream>
using namespace std;
//访问权限
//三种
//公共权限public       类内可以访问       类外可以访问
//保护权限protected    类内可以访问		  类外不可以访问	儿子可以访问父亲保护内容
//私有权限private	   类内可以访问		  类外不可以访问	儿子不可以访问父亲的私有内容
class Person {
public:
	//公共权限
	string m_Name;
protected:
	//保护权限
	string m_Car;//汽车
private:
	//私有权限
	int m_Password;//银行卡密码

public:
	void func() {
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};
int main() {
	Person p1;
	p1.m_Name = "李四";
	//p1.m_Car = "宝马";//保护权限内容在类外访问不到
	//p1.m_Password = "4444";//私有权限内容，类外访问不到
	system("pause");
	return 0;
}
class和struct的区别

class权限默认私有
struct权限默认公有

#include<iostream>
using namespace std;
class C1 {
	int m_A;//默认私有 
};

struct C2 {
	int m_A;//默认公有
};
int main() {
	//struct和class的区别
	//struct默认权限是 public
	//class默认权限是 private

	C1 c1;
	//c1.m_A = 100;
	C2 c2;
	c2.m_A= 100;
	system("pause");
	return 0;
}
成员属性私有化
#include<iostream>
using namespace std;
//成员属性设置为私有
//1.可以自己控制读写权限
//2.对于写可以检测数据有效性

//设计人类
class Person {
public:
	void setName(string name) {
		m_Name = name;
	}
	string getName() {
		return m_Name;
	}

	int getAge() {
		//m_Age = 0;//初始化为0岁
		return m_Age;
	}

	void setLover(string lover) {
		m_Lover = lover;
	}

	void setAge(int age) {
		if (age < 0||age>150) {
			m_Age = 0;
			cout << "你这个老妖精" << endl;
			return;
		}
		m_Age = age;
	}
private:
	string m_Name;

	int m_Age;

	string m_Lover;
};
int main() {

	Person p;
	p.setName("张三");
	cout << "姓名为：" << p.getName() << endl;
	p.setAge(1000);
	cout << "年龄为：" << p.getAge() << endl;
	

	p.setLover("苍井");
	system("pause");
	return 0;
}
封装案例

立方体

#include<iostream>
using namespace std;


class Cube {

private:
	int m_L;
	int m_W;
	int m_H;
	
public:
	//setter getter  方法
	void setL(int l) {
		m_L = l;
	}
	int getL() {
		return m_L;
	}

	void setW(int w) {
		m_W = w;
	}
	int getW() {
		return m_W;
	}

	void setH(int h) {
		m_H = h;
	}
	int getH() {
		return m_H;
	}

	//其他方法
	int calculateS() {
		return 2 * m_L * m_W + 2 * m_W * m_H + 2 * m_L * m_H;
	}

	int calculateV() {
		return m_H * m_L * m_W;
	}


	//利用成员函数来判断两个立方体是否相等
	bool isSameByClass(Cube c) {
		if (m_L == c.getL() && m_H == c.getH() && m_W == c.getW()) {
			return true;
		}
		return false;
	}

};

//利用全局函数来判断 两个立方体是否相等
bool isSame(Cube c1,Cube c2) {
	if (c1.getL() == c2.getL()&&c1.getH()==c2.getH()&&c1.getW()==c2.getW()) {
		return true;
	}
	return false;
}

int main() {
	//创建立方体对象
	Cube c1;
	c1.setL(10);
	c1.setH(10);
	c1.setW(10);
	cout << "c1的面积为：" << c1.calculateS() << endl;
	cout << "c1的体积为：" << c1.calculateV() << endl;
	//创建第2个立方体
	Cube c2;
	c2.setL(10);
	c2.setH(10);
	c2.setW(10);

	//利用全局函数判断
	bool ret = isSame(c1, c2);
	if (ret) {
		cout << "c1和c2相等" << endl;
	}
	else {
		cout << "c1和c2不相等" << endl;
	}
	//利用成员函数判断
	ret = c1.isSameByClass(c2);
	if (ret) {
		cout << "成员函数判断：c1和c2相等" << endl;
	}
	else {
		cout << "成员函数判断：c1和c2不相等" << endl;
	}
	system("pause");
	return 0; 
}

点和圆的关系

头文件
#pragma once
#include<iostream>
using namespace std;

//点类
class Point {
private:

	int m_X;
	int m_Y;


public:

//get set
	void setY(int y);

	int getY();
	
	void setX(int x);

	int getX();
};


#pragma once
#include<iostream>
using namespace std;
#include "point.h"
//圆类
class Circle {

private:
	int m_R;//半径

	Point m_Center;//圆心

public:
	//set get
	void setR(int r);
	int getR();
	void setCenter(Point center);
	Point getCenter();
};
源文件
#include "point.h"

//get set
void Point::setY(int y) {
	m_Y = y;
}
int Point::getY() {
	return m_Y;
}

void Point::setX(int x) {
	m_X = x;
}
int Point::getX() {
	return m_X;

}


#include"circle.h"

//set get
void Circle::setR(int r) {
	m_R = r;
}
int Circle::getR() {
	return m_R;
}
void Circle::setCenter(Point center) {
	m_Center = center;
}
Point Circle::getCenter() {
	return m_Center;
}
测试代码
#include<iostream>
using namespace std;
#include "circle.h"
#include "point.h"


//判断点和圆的关系
void isInCircle(Circle& c, Point& p) {
	//计算两点之间的距离的平方
	int distence =
		(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	//计算半径的平方
	int rDistence = c.getR() * c.getR();
	//判断关系
	if (distence == rDistence) {
		cout << "点在圆上" << endl;
	}
	else if (distence < rDistence) {
		cout << "点在圆内" << endl;
	}
	else {
		cout << "点在圆外" << endl;
	}
	
}
int main() {
	//创建圆
	Circle c;
	c.setR(10);
	Point center;
	center.setX(10);
	center.setY(0);
	c.setCenter(center);
	//创建点
	Point p;
	p.setX(10);
	p.setY(9);
	//判断两者之间的关系
	isInCircle(c, p);
	system("pause");
	return 0;
}

对象的初始化和清理

1.构造函数和析构函数，这两个函数被编译器自动调用，完成对象的初始化和清理工作
2.对象的初始化和清理工作是编译器强制要我们做的事，如果我们不提供构造和析构，编译器会提供，编译器提供的构造函数和析构函数是空实现

构造函数：

      只要作用在于创建对象时为对象成员属性赋值，构造函数由编译器自动调用，无需手动调用。

析构函数：

      主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：

1.没有返回值，也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造函数，无需手动调用，而且只会调用一次

析构函数语法：

1.析构函数没有返回值，也不写void
2.函数名称与类名相同，在名称前加上符号 ~
3.析构函数不可以有参数，因此不可以发生重载
4.函数在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

代码:
#include<iostream>
using namespace std;

//对象的初始化和清理

class Person {
	//1.构造函数进行初始化的操作
	//构造函数
public:
	Person() {
		cout << "Person的构造函数的调用" << endl;
	}

	//2.析构函数 进行清理
	~Person() {
		cout << "Person的析构函数调用" << endl;
	}

};

void test01() {
	Person p;//栈上的数据 test01执行完后，就释放这个对象
}
int main() {
	test01();
	//Person p;
	system("pause");
	return 0;
}
构造函数的分类及调用
两种分类方式：

      按参数分为：有参构造和无参构造
      按类型分为：普通构造和拷贝构造

三种调用方法：

      括号法
      显示法
      隐式转换法

代码：
#include<iostream>
using namespace std;

//构造函数的分类及调用
//分类
//按照参数分类  无参  有参
//按照类型分类  普通  拷贝
class Person {
public:
	//构造函数
	Person() {
		age = 10;
		cout << "Person的无参构造函数调用" << endl;

	}

	Person(int a) {
		age = 10;
		cout << "Person的有参构造函数调用" << endl;

	}

	//拷贝构造函数
	Person(const Person &p) {
		//将传入的人身上的所有属性，拷贝到我身上
		cout << "Person的拷贝构造函数调用" << endl;
		age = p.age;
	}

	//析构函数
	~Person() {
		cout << "Person 的析构函数调用" << endl;
	}

	int age;
};
//调用
void test01() {
	//1.括号法
	//Person p1;//默认构造函数的调用
	//Person p2(10); //有参构造函数
	//Person p3(p2);//拷贝构造函数

	//注意事项
	//调用默认构造函数时候，不要加()
	//因为下面这行代码，编译器会认为是一个函数声明 不会认为在创建对象
	//Person p1();


	//cout << "p2的年龄为：" <<p2.age<< endl;
	//cout << "p3的年龄为：" << p3.age << endl;


	//2.显示法
	//Person p1;
	//Person p2 = Person(10);//有参构造
	//Person p3 = Person(p2);//拷贝构造

	//Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	//cout << "aaaa" << endl;


	//注意事项2
	//不要利用拷贝构造函数来初始化匿名对象   初始化匿名对象 编译器会认为 Person (p3)==Person p3;对象的声明
	//Person(p3);


	//3.隐式转换法
	Person p4 = 10;//相当于写了 Person p4=Person（10）； 编译器来转换
	Person p5 = p4;//拷贝构造
}
	
int main() {
	test01();
	system("pause");
	return 0;
}
拷贝构造函数的调用时机
三中情况：

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象

代码：
#include<iostream>
using namespace std;

//拷贝构造函数的调用时机



class Person {
public:
	Person() {
		cout << "Person的默认构造函数调用" << endl;
	}

	~Person() {
		cout << "Person的析构函数调用" << endl;
	}
	
	Person(int age) {
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}

	Person(const Person& p) {
		m_Age = p.m_Age;
		cout << "Person的拷贝构造函数调用" << endl;
	}

	int m_Age;
};


//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20);
	Person p2(p1);

	cout << "p2的年龄为：" << p2.m_Age << endl;
}

//2.值传递的方式给函数参数传值
void doWork(Person p) {//值传递是将实参拷贝一份然后传给形参，也就是调用拷贝构造函数来拷贝
						//也就说明为什么值传递不改变实参的值，因为他用拷贝构造函数将实参拷贝了一份副本给形参，
						//改变的只是这份副本

}
void test02() {
	Person p;
	doWork(p);
}
//3.值的方式返回局部对象
Person doWork2( ) {
	Person p1;
	cout << (int*)&p1 << endl;//此行代码打印的地址和下面的地址不同，也说明了返回的p1是新拷贝的
	return p1;//局部变量在栈区，调用完会被释放内存，但是以值的方式返回p1而不是指针，
				//将会在p1被释放之前调用拷贝构造函数来
				//拷贝一份新的来用来返回		
}

void test03() {
	Person p=doWork2();
	cout << (int*)&p << endl;
}

int main() {
	//test01();

	//test02();

	test03();
	system("pause");
	return 0;
}
构造函数的调用规则

默认情况下，c++编译器至少给一个类添加三个函数
1.默认构造函数(无参，函数体为空）
2.默认析构函数(无参，函数体为空)
3.默认拷贝构造函数，对属性进行值拷贝

构造函数：
如果用户定义了有参构造函数，c++不在提供默认的无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不在提供其他任何构造函数

代码：
#include<iostream>
using namespace std;

//构造函数的调用规则
//1.只要创建一个类，c++就会给每个类添加至少三个函数
//默认构造（空实现）
//析构（空实现）
//拷贝构造（值拷贝）


class Person {
public:
	/*Person() {
		cout << "Person的默认构造函数调用" << endl;
	}*/
	//Person(int age) {
	//	cout << "Person的有参构造函数调用" << endl;
	//	m_Age = age;
	//}
	Person(const Person &p) {
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}
	~Person() {
		cout << "Person的析构函数调用" << endl;
	}

	int m_Age;
};

//void test01() {
//	Person p;
//	p.m_Age = 18;
//
//	Person p2(p);
//
//	cout << "p2的年龄为：" << p2.m_Age << endl;
//}

void test02() {
	Person p;



}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}
深拷贝与浅拷贝
原理图：

在这里插入图片描述

浅拷贝：

          简单的赋值拷贝操作

深拷贝：

          在堆区内重新申请空间，进行拷贝操作

代码：
#include<iostream>
using namespace std;
//深拷贝与浅拷贝

class Person {
public:
	Person() {
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age,int height) {

		m_Age = age;
		m_Height = new int(height);//利用new把这个数据创建在堆区 并用m_Height指针去接收这个堆区的数据
		cout << "Person的有参构造函数调用" << endl;
	}


	//自己实现一个拷贝构造函数 来 解决浅拷贝带来的问题
	Person(const Person& p) {
		cout << "Person 拷贝构造函数的调用" << endl;
		//编译器写的
		m_Age = p.m_Age;
		//m_Height = p.m_Height;//编译器默认实现（浅拷贝）就是这行代码
		

		//深拷贝操作

		m_Height = new int(*p.m_Height);
	}


	~Person() {
		//析构代码，将堆区开辟的数据做释放操作
		if (m_Height != NULL) {
			delete m_Height;
			m_Height = NULL;//防止野指针出现将其置空
		}
		cout << "Person的析构函数调用" << endl;
	}

	int m_Age;//年龄

	int* m_Height;//身高
};

void test01() {

	Person p1(18,160);

	cout << "p1的年龄为：" << p1.m_Age << "身高为：" << *p1.m_Height << endl;

	Person p2(p1);

	cout << "p2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}
结论：

          如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表
作用：

          C++提供初始化列表语法，用来初始化属性

代码：
#include<iostream>
using namespace std;

//初始化列表
class Person {
public:

	传统初始化操作
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表初始化属性
	Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) {

	}

	int m_A;
	int m_B;
	int m_C;
};

void test01() {
	//Person p(1, 2, 3);
	Person p(30, 20, 10);
	//Person p;
	cout << "mA" << p.m_A << "  mB" << p.m_B << "  mC" << p.m_C << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}
类对象作为类成员

C++类中的成员，可以是另一个类的对象，我们称该成员为 对象成员

代码：
#include<iostream>
using namespace std;

//类对象作为类成员
//手机类
class Phone {

public:
	Phone(string pName) {
		cout << "Phone的构造函数调用" << endl;
		m_PName = pName;
	}
	~Phone() {
		cout << "Phone的析构函数调用" << endl;
		
	}

	//手机品牌名称
	string m_PName;
};

//人类
class Person {
public:

	Person(string name,string pName) :m_Name(name),m_Phone(pName){
		cout << "Person的构造函数调用" << endl;
	}
	~Person(){
		cout << "Person的析构函数调用" << endl;
	}
	string m_Name;

	Phone m_Phone;
};

//当其他类的对象作为本类成员，构造时先构造其他的类对象，再构造自身 ，  析构的顺序与构造相反
void test01() {
	Person p("张三", "苹果MAX");
	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << "手机" << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}
结论：

构造由内到外 析构由外到内

落落落Luo
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 4835
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
【C++学习笔记】 1.2 访问权限
NGB1998的博客
09-07 277
访问权限
C++入门基础(四) 类 访问权限限定字符 this指针
dream_i_success的博客
03-14 291
  众所周知，C++是一门面向对象的语言，其关注的是对象，是将一件事情拆分成不同的对象，靠对象之间的交互完成的。就相当于，我们建一栋房子，有专门的打地基的，专门盖房子的，专门装潢的等等，而盖房子的东家只用和他们的负责人沟通就行，而至于这些负责人怎么把活干出来则是他们底下自己的事情，这样的形式便称作面向对象，如此将大大降低使用者的难度。这里我们将介绍C++中的一个特殊的结构——类。 类 ...
C++类成员访问权限
weixin_30709809的博客
10-11 287
C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员。 Java、C# 程序员注意，C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有...
C++程序设计第四章
成长、蜕变
09-21 495
第四章 类和对象 **大家想一起学习交流的可以加群，QQ：755422568。** 一、类及其实例化 （1）、定义类 类要先声明后使用，具有惟一标识符的实体，不能使用关键字修饰，不能在类声明中对数据成员使用表达式进行初始化。 1）、声明类 类是对一组性质相同对象的程序描述。 类中所有成员默认声明为private权限。 class Point{ //类名Point private: ...
C++学习笔记
热门推荐
ftm_csdn的博客
04-16 1万+
C++是C语言的超集。
C++ 学习笔记
weixin_42098295的博客
04-29 1499
继承可以让新的类继承现有类的特性，多态通过接口的多种实现提供了函数行为的多样性，而封装则隐藏了数据的内部表示，只暴露必要的操作接口，这有助于减少系统的复杂性并提高其安全性。内存管理还涉及到堆和栈的使用，其中栈用于存储局部变量和函数调用的信息，而堆则用于动态内存分配，通常由程序员手动管理，这在处理大量数据或不确定数据大小时特别有用。在组织大型程序时，命名空间提供了避免名字冲突的方式，使得相同名字的变量或函数可以在不同的命名空间下共存，极大地增强了代码的模块化和可维护性。，用来存储数字、字符和布尔值。
c++学习笔记
Tinelines的博客
03-16 1105
1.namespace 命名空间 1.1命名空间的三种声明方式 using namespace; using namespace::func1; namespace::func1();
z3 C++学习笔记
T_T233333333的博客
03-06 3352
因为项目需要使用z3库来解决问题，所以自己学习了一下，结果发现网上教程比较少，而且大部分都是使用Python，而我本人是C++的忠实信徒，在知道C++也可以使用z3库以后我毫不犹豫地着手用C++使用z3，但是我很快发现，网上基本没有关于C++使用z3的教程（中文社区一点都没有），因此我记录一下我自己的学习过程希望能够帮助到其他学习的人。 教程链接 网上现有的有三个教程： 官方example.cpp文档：https://github.com/Z3Prover/z3/blob/master/examples.
UE C++学习笔记
weixin_44212242的博客
05-16 3304
UE C++入门级程序编制笔记，基础中的基础，了解UE C++的书写规范和一般要求，实现蓝图，C++混合开发。
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1183
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 266
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1126
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 366
C++ | Leetcode C++题解之第275题H指数II
C++学习笔记：面向过程与C++概述
"这篇文档是关于C++的学习笔记，主要关注面向过程的编程思想，并提到了C++的一些基本概念和历史。文档指出C++是由比雅尼·斯特劳斯特鲁普博士开发的一种通用编程语言，它在C语言的基础上增加了面向对象、数据抽象和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值