C++快速入门

已于 2023-08-21 15:00:22 修改
阅读量252 收藏
点赞数
分类专栏： 其他 文章标签： c++ 开发语言
于 2022-11-24 06:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43441284/article/details/127989592
版权

基本知识

面向对象的编程：
1、自己创建类
2、自己创建对象

  • 类的形式：
class student 
{
	srting name;
	int age;
}
  • 公有、私有
  • 私有的函数需要借用公有的方法调用
class student 
{
public://外部可读写
	srting name;
	private://外部看不到 外部不可读写
	int age;
}
  • 使用一个类：

student Jane;//创建一个 student 类的对象 名字将Jane Jane.name = “xiaohua”;//赋值

  • 什么是成员函数
不同的函数可以使用一样的名字，但是形成不同
class student 
{
public:
 	srting name;
 	int age;
	 bool set (int a);
	 bool set (srting a);//两函数形参不同
}
//成员函数的定义：
bool set （srting a）
{
	name = a;
	return true；
}
bool set （int a）
{
	age = a;
	return true；
}

构造函数

不带参数的构造函数

class student 
{
public:
	srting name;
	int age;
	student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
}
student：：student()//构造函数定义，冒号两边一样，没有输入值
{
	age = 20;//构造函数里面，可以对全部的成员变量一个默认值
	name = "xiaohua";
}

以后我再主函数定义新的变量时，变量就会有一个默认值，就是构造函数里面定义的

带参数的构造函数

class student 
{
public:
	srting name;
	int age;
	student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
	student(int a, string b);//带参数的构造函数，还是保存和类一样的名字，根据不同的参数进行区别
	
}
student::student()//构造函数定义，冒号两边一样，没有输入值
{
	age = 20;//构造函数里面，可以对全部的成员变量一个默认值
	name = "xiaohua";
}

student::student(int a, string b)//构造函数定义，冒号两边一样
{
	age = a;//构造函数里面，将输入的值赋值给对象
	name = b;
}

int main()
{
	student aa;//没有带参数的构造函数默认赋值
	student bb(23,"小白");//在定义对象时赋值
	return 0;
}

析构函数

student *p = new student(88,"愚公");//创建一个指针p,指向一个新的对象
delete p;//删除指针

//析构函数,执行删除指针时会调用
student :: ~student ()
{
	cout<<"delete object";
}

常成员函数const

  • 一个方法只读取属性，而不修改属性，就是常成员函数
class student 
{
public:
	srting name;
	int age;
	bool set (int i);//普通成员函数声明，又叫方法
	bool read() const;//后面加const，表示这个函数只读不写
	
}
bool student :: read() const//后面加const，表示这个函数只读不写
{
	cout<<name;//打印姓名
	cout<<age;//打印年龄
	return true;
}

int main()
{
	student aa;//创建对象
	aa.read();//在创建对象后，调用read方法
	return 0;
}

//实现上可以不使用const,普通方法也可以读数据，加const只是为了安全起见，防止意外修改数据。
//更加不正规的做法就是直接读取：aa.age,在正规的程序当中还是会使用const来读取。

静态成员函数

  • 静态成员数据 （ static）：描述全局，又与具体的对象属性无关的变量
  • 读取静态成员数据的方法，叫静态成员函数
class student 
{
public:
	srting name;
	int age;
	student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
	static int cnt://static 表示静态成员数据，统计有多少个对象
	static int count()://static 表示静态成员函数，返回有多少个对象
	
}

student::student()//构造函数定义，冒号两边一样，没有输入值
{
	age = 20;//构造函数里面，可以对全部的成员变量一个默认值
	name = "xiaohua";
	cnt = cnt + 1;
}

int student ::count()
{
	return cnt;//返回静态成员数据，统计有多少个对象
}

int main()
{
	student aa;//创建对象
	student bb;//创建对象
	aa.count();//bb.count();//student ::count();不依赖对象的静态函数
	return 0;
}

正规写法

class student 
{
public:
	bool set (int i);//普通成员函数声明，又叫方法
	bool read() const;//后面加const，表示这个函数只读不写
private:
	srting name;
	int age;
}
  • 一般把方法全部放到public中
  • “属性”放在privatezho
  • 目的是防止类的外部随意篡改数据
  • 通过函数来修改数据时，一般都具有防错机制，满足条件才能修改

派生继承



class student 
{
public:
	bool set (int i);//普通成员函数声明，又叫方法
	bool read() const;//后面加const，表示这个函数只读不写
private:
	srting name;
	int age;
}

class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
}

class postgraduste : public student //研究生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting research;//这个行新增定义一个公开的字符串属性 research，比如研究生的研究方向：芯片设计
}

int main()
{
	undergraduate aa;//创建本科生对象
	postgraduste bb;//创建研究生对象
	aa.set(33);//子类可以调用父类的方法
	return 0;
}
  • 将student 当中的private变为protect,研究生类就可以继承student 的protect下的内容，而且对应student 来说，protect下的内容和private下的是一样的
> class undergraduate : private student//私有继承，继承所得的public下的内容变为private 下的，不继承private 下的内容
> class undergraduate : protect student//保护继承，继承所得的public下的内容和protect 下的内容都为protect 下的内容
  • 子类只能调用父类的构造函数

子类的构造函数

class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
		undergraduate();//
		undergraduate(int a,string b,string c);//
}

undergraduate :: undergraduate()
{	
	course = "math"
	
}
//带参数的构造函数
undergraduate :: undergraduate(int a,string b,string c):st`在这里插入代码片`udent (a,b)
{	
	course = c;
}
int main()
{
	undergraduate aa;//创建本科生对象
	postgraduste bb(22,"xiaohua","math");//创建对象，并且赋初值
	aa.set(33);//子类可以调用父类的方法
	return 0;
}

多态

  • 重载：同名的方法，根据不同形参，执行不同的方法
  • 隐藏：父类当中定义一个方法，子类可以重新定义，重新定义的方法输入格式相同或者不同都可以
class student 
{
public:
	bool set (int i);//普通成员函数声明，又叫方法
	bool read() const;//后面加const，表示这个函数只读不写
	void study(bool a);
private:
	srting name;
	int age;
}
void student :: study(bool a)
{
	cout<<"好好睡觉"
}

class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
		void study(bool a);
}

void undergraduate :: study(int a)
{
	cout<<"好好吃饭"
}

int main()
{
	student aa;//创建父对象
	postgraduste bb;//创建子对象
	bb。study(2);//打印好好吃饭
	aa.study(ture);//打印好好睡觉
	bb。study(ture);//报错,父类方法被隐藏了
	return 0;
}

  • 指针

    • 父类的指针可以指向子类，子类的指针不可以指向父类
    • 指向子类的父类指针也只能调用父类的方法和属性，不能调用子类的方法和属性

  • 虚函数（virtual）

class student 
{
public:
	bool set (int i);//普通成员函数声明，又叫方法
	bool read() const;//后面加const，表示这个函数只读不写
virtual	void study();
private:
	srting name;
	int age;
}
void student :: study()
{
	cout<<"好好学习"
}

class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
	virtual	void study();
}

void undergraduate :: study()
{
	cout<<"好好吃饭"
}
class postgraduste : public student //研究生类定义，冒号后面表示从student 类公有派生而来
{
	public:
		srting research;//这个行新增定义一个公开的字符串属性 research，比如研究生的研究方向：芯片设计
	virtual	void study();
}
void postgraduste :: study()
{
	cout<<"开开心心"
}

int main()
{
	student aa;//创建父对象
	postgraduste bb;//创建子对象
	undergraduate cc;//创建子对象
	student *p;
	p = &aa,
	p->study();//打印好好学习
	p = &bb,
	p->study();//打印开开心心
	p = &cc,
	p->study();//打印好好吃饭
	return 0;
}

纯虚函数与抽象函数

class student 
{
public:
	student ();//抽象类也有构造函数
	student (int a,string b);//构造函数重载
virtual	void study() =0;//声明方法，前面有virtual还有=0,表示纯虚函数,只有声明没有定义
}

int main()
{
	student aa;// 报错 不允许创建对象
	postgraduste bb;//创建子对象
	undergraduate cc;//创建子对象
	student *p;
	p = &bb,
	p->study();//打印开开心心
	p = &cc,
	p->study();//打印好好吃饭
	return 0;
}

回调实例展示


#include <iostream>
#include <map>
#include <string>
#include "stdio.h"
using namespace std;

class student {
 public:
  string name;
  int age;
  ~student();
  student();  // 这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
  student(
      int a,
      string
          b);  // 带参数的构造函数，还是保存和类一样的名字，根据不同的参数进行区别

  bool set(int a);
  bool set(string a);  // 两函数形参不同

  bool read() const;  // 后面加const，表示这个函数只读不写
  static void stuone(int i) {
    std::cout << "I an first student" << std::endl;  // 打印姓名
    std::cout << i << std::endl;                     // 打印姓名
  }
  void FunB1(void (*callback)()) {
    printf("I'am ProgramB.FunB1() and be called..\n");
    callback();
  }
};

// 成员函数的定义：
bool student::set(string a) {
  name = a;
  return true;
}
bool student::set(int a) {
  age = a;
  return true;
}

student::student()  // 构造函数定义，冒号两边一样，没有输入值
{
  age = 20;  // 构造函数里面，可以对全部的成员变量一个默认值
  name = "xiaohua";
}

student::student(int a, string b)  // 构造函数定义，冒号两边一样
{
  age = a;  // 构造函数里面，将输入的值赋值给对象
  name = b;
}
// 析构函数,执行删除指针时会调用
student ::~student() { std::cout << "delete object" << std::endl; }

bool student ::read() const  // 后面加const，表示这个函数只读不写
{
  std::cout << name << std::endl;  // 打印姓名
  std::cout << age << std::endl;   // 打印年龄
  return true;
}
typedef void (*FuncPtr1)(int);
std::map<std::string, FuncPtr1> g_TmpCmdMap;
std::map<std::string, int> g_Tmpage;

// 回调函数的注册函数
int registfun(int age, string name, void (*FuncPtr1)(int)) {
  student aa;  // 创建对象
  aa.set(age);
  aa.set(name);
  aa.read();  // 在创建对象后，调用read方法
  g_Tmpage[name] = age;
  g_TmpCmdMap[name] = FuncPtr1;
  // aa.FunB1(FuncPtr1);
  return 0;
}

int checkoutfun(string name) {
  std::map<std::string, FuncPtr1>::iterator g_TmpCmdMap1;
  std::map<std::string, int>::iterator g_Tmpage1;
  g_TmpCmdMap1 = g_TmpCmdMap.find(name);

  if (g_TmpCmdMap1 == g_TmpCmdMap.end()) {
    printf("%s %d 11111111111111111111\n", __func__, __LINE__);
    return 0;
  }

  g_Tmpage1 = g_Tmpage.find(name);
  if (g_Tmpage1 == g_Tmpage.end()) {
    printf("%s %d 222222222222222222\n", __func__, __LINE__);
    return 0;
  }
  printf("%s %d 33333333333333333\n", __func__, __LINE__);
  g_TmpCmdMap[name](g_Tmpage[name]);
  return 0;
}
int main(int argc, char *argv[]) {
  printf("%s %d \n", __func__, __LINE__);
  registfun(181, "hhh1", student ::stuone);
  registfun(182, "hhh2", student ::stuone);
  registfun(183, "hhh3", student ::stuone);
  registfun(184, "hhh4", student ::stuone);
  registfun(185, "hhh5", student ::stuone);
  registfun(186, "hhh6", student ::stuone);
  registfun(187, "hhh7", student ::stuone);
  printf("%s %d ============================ \n", __func__, __LINE__);
  checkoutfun("hhh2");
  checkoutfun("hhh99");
  return 0;
}
li星野
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++快速入门1
08-04
最后，总结来说，C++快速入门涉及到的关键概念包括基本语法、数据类型、输入输出、变量、运算符、控制流、循环、数组、字符串和函数。通过掌握这些基础知识，你可以开始编写简单的C++程序，并逐渐深入到更复杂的编程...
C++快速入门课件全解
11-12
C++是一种广泛应用于系统软件、应用软件、游戏开发、嵌入式系统等...通过这个“C++快速入门课件全解”，你将能够构建扎实的C++基础，为后续的深入学习和实际项目开发打下坚实的基础。祝你在C++的学习旅程中取得成功！
C++快速入门教程
10-04
作为C++的快速入门教程，我们将深入探讨C++的基础概念、语法结构以及它如何与其他编程语言相比有所不同。 首先，C++是在C语言的基础上发展起来的，因此，它继承了C语言的高效性和底层控制能力。C++引入了面向对象...
小甲鱼C++快速入门课件笔记
02-02
小甲鱼的C++快速入门课程是一门针对初学者精心设计的教程，旨在帮助学习者快速掌握C++编程基础知识。以下是对课程笔记中关键知识点的详细解析： 1. **语言与思想介绍**：C++是一种静态类型的、编译式的、通用的、大...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1100
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 218
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 155
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 978
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1039
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
【C++】获取环境变量
Badme
07-18 40
【C++】获取环境变量
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
2301_80220607的博客
07-12 4366
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
【C++修炼之路 第三章】内存管理：new 与 delete
最新发布
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 575
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
C++ std::partial_sort_copy 用法
07-16 292
部分排序，即选出前n个最大值或者最小值，并将其保存到另外一个容器中。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 435
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 597
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C语言中的指针函数和函数指针
letterljhx的博客
07-18 288
C语言中的指针函数和函数指针
C++静态成员
2402_84626835的博客
07-14 191
对于类中的非静态数据成员，每一个类对象都拥有一个副本，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。（1）由于在类的声明中仅仅是对静态数据成员进行了引用声明，因此必须在文件作用域的某个地方对静态数据成员进行定义并进行初始化，即应在类体外对静态数据成员进行初始化（静态数据成员的初始化与它的访问控制权限无关）。静态数据成员的值对每个对象都是一样的，它的值可以被任何一个对象更新，从而实现了同一类的不同对象之间的数据共享。9.1 静态数据成员。
C语言 使用指针的2个小例子
waterHBO的博客
07-14 312
指针这部分，还是要多写多看，反复翻看笔记。
C++快速入门：Sams Teach Yourself in One Hour a Day
"C++快速入门教程，适合初学者，通过一天的学习掌握基本的C++编程概念和技能。" 在本教程中，你将学习到C++编程的基础知识，这是一门强大的、面向对象的编程语言，具有丰富的库支持和广泛应用。教程作者Siddhartha ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

li星野

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

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

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

打赏作者

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

抵扣说明：

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

余额充值