📋 前言
🌈个人主页：Sarapines Programmer
🔥 系列专栏：本期文章收录在《C语言闯关笔记》，大家有兴趣可以浏览和关注，后面将会有更多精彩内容！
⏰翰墨致赠：文墨扬长风，情随碧波舞。江山孕雄心滚滚，志立云霄梦遨游。
🎉欢迎大家关注🔍点赞👍收藏⭐️留言📝
🔔作者留言：欢迎来到我的编程学习笔记！这里是一个探索编程世界的秘境，我的学习笔记为你揭开C/C++语言的神秘面纱。在这个学习笔记中，我不仅分享C/C++的基础知识和高级技巧，还包含实用技术和项目经验的宝贵经验。无论你是初学者还是经验丰富的程序员，这个学习笔记将为你呈现出奇妙的编程魔法，帮助你在C/C++的编程森林中展开一场精彩的学习之旅。你准备好了吗？跟着我，一起编织属于我们自己的编程魔法吧！
题库地址：牛客网在线编程_语法篇_C语言入门
目录
📋 前言
🌐第一部分 指针篇
😎1.1 获取字符串长度
😎1.2 复制部分字符串
😎1.3 编写函数实现两数交换（指针方式）
😎1.4 利用指针遍历数组
😎1.5 牛牛的新数组求和
😎1.6 牛牛的排序
🌐第二部分 链表篇
2.0 单链表程序示例（掌握了再继续）：
😎2.1 牛牛的单向链表
😎2.2 牛牛的链表交换
😎2.3 牛牛的单链表求和
😎2.4 牛牛的双链表求和
😎2.5 牛牛的链表删除
😎2.6 牛牛的链表添加节点
🌐第三部分 结构体与类篇
😎3.1 KiKi定义电子日历类
😎3.2 KiKi设计类继承
😎3.3 牛牛的书
😎3.4 牛牛的平面向量
😎3.5 牛牛的时钟
😎3.6 结构体简单使用
🌐第一部分 指针篇
😎1.1 获取字符串长度
描述
键盘输入一个字符串，编写代码获取字符串的长度并输出，要求使用字符指针实现。
输入描述：
键盘输入一个字符串
输出描述：
输出字符串的长度
示例1
输入： helloworld 输出： 10
💡解决如下：
解法一：
#include <iostream>
using namespace std;
int main(){
char str[100];
cin.getline(str,sizeof(str));
char *ptr=str;
int count=0;
while (*ptr!='\0')
{
count++;
ptr++;
}
cout<<count<<endl;
}解法二：
#include <iostream>
using namespace std;
int main(){
string s;
getline(cin,s);
char *p=&s[0];
int count=0;
for(int i=0;p[i] !='\0';i++){
count++;
}
cout<<count<<endl;
return 0;
}😎1.2 复制部分字符串
描述
键盘输入一个长度为len（1 <= len < 30）的字符串，再输入一个正整数 m（1 <= m <= len），将此字符串中从第 m 个字符开始的剩余全部字符复制成为另一个字符串，并将这个新字符串输出。要求用指针处理字符串。
输入描述：
键盘输入一个长度为len（1 <= len < 30）的字符串，再输入一个正整数 m（1 <= m <= len）
输出描述：
输出复制的新字符串
示例1
输入： helloworld 6 输出： world
💡解决如下：
#include <iostream>
using namespace std;
int main(){
char str[100];
cin.getline(str,sizeof(str));
int n;
cin>>n;
char *ptr=str;
for(int i=0;i<n-1;i++,ptr++){
}
while(*ptr!='\0'){
cout<<*ptr;
ptr++;
}
cout<<endl;
}解法二：
#include <iostream>
using namespace std;
int main(){
string s,t;
getline(cin,s);
int n;
cin>>n;
char *p=&s[0];
for(int i=n-1;p[i]!='\0';i++){
t+=p[i];
}
cout<<t<<endl;
return 0;
}😎1.3 编写函数实现两数交换（指针方式+引用方式）
描述
编写一个函数，实现两个整数的交换，要求采用指针的方式实现。
输入描述：
键盘输入2个整数 m 和 n
输出描述：
输出交换后m 和 n 的值，中间使用空格隔开
示例1
输入: 2 3 输出: 3 2
💡解决如下（指针方式）：
#include <iostream>
using namespace std;
void swap(int *p1,int *p2);
int main(){
int n,m;
cin>>n;
cin>>m;
int *p1,*p2;
p1=&n;
p2=&m;
swap(p1,p2);
cout<<n<<" "<<m<<endl;
}
void swap(int *p1,int *p2){
int t=*p1;
*p1=*p2;
*p2=t;
}💡解决如下（引用方式）：
#include <iostream>
using namespace std;
void Swap(int *p1,int *p2){
int t=*p1;
*p1=*p2;
*p2=t;
}
void Swap2(int &x,int &y){
int t=x;
x=y;
y=t;
}
int main(){
int m,n;
cin>>m>>n;
int *p1=&m,*p2=&n;
int &x=m,&y=n;
//Swap(p1,p2);
Swap2(x,y);
cout<<m<<" "<<n<<endl;
return 0;
}😎1.4 利用指针遍历数组
描述
键盘随机输入 6 个整数，将这些数据保存到数组中，利用指针遍历数组中的元素并打印。
输入描述：
键盘随机输入 6 个整数
输出描述：
输出数组中的所有元素，每个元素中间使用空格隔开
例如：10 20 30 40 50 60
示例1
输入： 10 20 30 40 50 60 输出： 10 20 30 40 50 60
💡解决如下：
#include <iostream>
using namespace std;
int main(){
int MaxSize=6;
int *arr=new int[MaxSize];
int *p=arr;
for(int i=0;i<MaxSize;i++){
cin>>*(p+i);
}
p=arr;//重定向
for(int i=0;i<MaxSize;i++){
cout<<*(p+i)<<" ";
}
cout<<endl;
delete [] arr;
return 0;
}💡一般思路：
#include <iostream>
using namespace std;
int main(){
int MaxSize=6;
int *arr=new int[MaxSize];
for(int i=0;i<MaxSize;i++){
cin>>arr[i];
}
for(int i=0;i<MaxSize;i++){
cout<<arr[i]<<" ";
}
cout<<endl;
delete [] arr;
return 0;
}😎1.5 牛牛的新数组求和
描述
牛牛学习了指针相关的知识，想实现一个 int cal(int *array,int n) 的函数求出长度为 n 的数组的和。
输入描述：
第一行输入一个正整数 n ，表示数组的长度
第二行输入 n 个正整数，表示数组中每个数字的值
输出描述：
实现 int cal(int *array,int n) 求出数组array的和
示例1
输入： 5 2 8 1 9 5 输出： 25
💡解决如下：
#include <iostream>
using namespace std;
int cal(int *array,int n);
int main(){
int n;
cin>>n;
int arr[100];
//int len=sizeof(arr)/sizeof(int);
for(int i=0;i<n;i++){
cin>>arr[i];
}
cout<<cal(arr,n)<<endl;
}
int cal(int *array,int n) {
int sum=0;
for(int i=0;i<n;i++){
sum+=array[i];
}
return sum;
}解法二(new)：
#include <iostream>
using namespace std;
int cal(int *array,int n) {
int sum=0;
for(int i=0;i<n;i++){
sum+=array[i];
}
return sum;
}
int main(){
int maxSize;
cin>>maxSize;
int *a=new int[maxSize];
for(int i=0;i<maxSize;i++){
cin>>a[i];
}
cout<<cal(a,maxSize)<<endl;
delete [] a;
return 0;
}解法三（vector）：
#include <iostream>
#include <vector>
using namespace std;
int cal(vector<int> array,int n) {
int sum=0;
for(int i=0;i<n;i++){
sum+=array[i];
}
return sum;
}
int main(){
int maxSize;
cin>>maxSize;
vector <int> a;
for(int i=0;i<maxSize;i++){
int k;
cin>>k;
a.push_back(k);
}
cout<<cal(a,maxSize)<<endl;
return 0;
}😎1.6 牛牛的排序
描述
牛牛试图给一个长度为 n 整数数组排序，即实现一个 void sort(int *array,int n)
输入描述：
第一行输入一个正整数 n ，表示数组长度。
第二行输入 n 个正整数，表示数组中每个元素的值
输出描述：
输出排序后的数组
示例1
输入： 5 2 9 8 1 3 输出： 1 2 3 8 9
💡解决如下：
#include <iostream>
using namespace std;
void sort(int *array, int n);
int main()
{
int n;
cin >> n;
int arr[100];
// int len=sizeof(arr)/sizeof(int);
for (int i = 0; i < n; i++)
{
cin >> arr[i];
}
sort(arr, n);
for (int i = 0; i < n; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
void sort(int *array, int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
int t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
}
}
}
}解法二（new）：
#include <iostream>
using namespace std;
void sort(int *array,int n) {
for(int i=0;i<n-1;i++){
for(int j=0;j<n-1;j++){
if(array[j]>array[j+1]){
int t=array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
}
int main(){
int maxSize;
cin>>maxSize;
int *a=new int[maxSize];
for(int i=0;i<maxSize;i++){
cin>>a[i];
}
sort(a,maxSize);
for(int i=0;i<maxSize;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}解法三（vector）：
#include <iostream>
#include <vector>
using namespace std;
void sort(vector <int> &array,int n) {
for(int i=0;i<n-1;i++){
for(int j=0;j<n-1;j++){
if(array[j]>array[j+1]){
int t=array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
}
int main(){
int maxSize;
cin>>maxSize;
vector <int> a;
for(int i=0;i<maxSize;i++){
int k;
cin>>k;
a.push_back(k);
}
sort(a,maxSize);
for(int value:a){
cout<<value<<" ";
}
cout<<endl;
return 0;
}🌐第二部分 链表篇
知识回顾：【数据结构】链表—C/C++实现-CSDN博客
2.0 单链表程序示例（掌握了再继续）：
#include <stdio.h>
#include <stdlib.h>
//定义单链表
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
//创建单链表
void CreateLNode(LNode **L,int a[],int n){
LNode *s,*r;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//输出单链表
void DispLNode(LNode **L){
LNode *p=*L;
while (p->next!=NULL){
printf("%d ",p->next->data);
p=p->next;
}
printf("\n");
}
//插入
void InsertLNode(LNode **L,int i,int e){
LNode *p=*L,*s,*q;
for(int j=0;j<i-1 && p->next!=NULL;){//定位到被插位置的前一个
p=p->next;
j++;
}
if(p==NULL){
printf("error!\n");
}
else{
s=(LNode *)malloc(sizeof(LNode));
s->data=e;
q=p->next;
s->next=q;
p->next=s;
}
}
//删除
void DelLNode(LNode **L,int i){
LNode *p=*L;
for(int j=0;j<i-1 && p->next!=NULL;){//定位到被删除位置的前一个
p=p->next;
j++;
}
if(p==NULL){
printf("error!\n");
}
else{
p->next=p->next->next;
}
}
//销毁
void DestroyLNode(LNode **L){
LNode *p=*L,*q=(*L)->next;
while (p!=NULL){
free(p);
p=q;
q=q->next;
}
}
int main(){
int arr[]={0,1,2,3,4,5};
int n=sizeof(arr)/sizeof(arr[0]);
LNode *L;
//测试创建
CreateLNode(&L,arr,n);
DispLNode(&L);
//测试插入
InsertLNode(&L,2,3);
DispLNode(&L);
//测试删除
DelLNode(&L,2);
DispLNode(&L);
//测试销毁
DestroyLNode(&L);
DispLNode(&L);
return 0;
}
/*输出
0 1 2 3 4 5
0 3 1 2 3 4 5
0 1 2 3 4 5
*/😎2.1 牛牛的单向链表
描述
牛牛从键盘输入一个长度为 n 的数组，问你能否用这个数组组成一个链表，并顺序输出链表每个节点的值。
输入描述：
第一行输入一个正整数 n ，表示数组的长度
输出描述：
制作一个链表然后输出这个链表的值
示例1
输入： 4 5 4 2 1 输出： 5 4 2 1
💡解决如下：
#include <iostream>
#include <stdlib.h>
using namespace std;
struct LNode{
int data;
struct LNode *next;
};
//创建
void CreateLNode(LNode **L,int *a,int n){
LNode *r,*s;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//输出
void DispLNode(LNode **L){
LNode *p=*L;
while(p->next!=NULL){
cout<<p->next->data<<" ";
p=p->next;
}
cout<<endl;
}
int main(){
int maxSize;
cin>>maxSize;
int *a=new int[maxSize];
for(int i=0;i<maxSize;i++){
cin>>a[i];
}
LNode *L;
CreateLNode(&L,a,maxSize);
DispLNode(&L);
delete [] a;
return 0;
}😎2.2 牛牛的链表交换
描述
牛牛尝试把一个长度为 n 的数组转换成链表并把链表前两个节点交换位置和把链表最后两个节点交换位置。
输入描述：
第一行输入一个正整数 n 表示数组的长度
第二行输入 n 个正整数，表示数组中各个元素的值
输出描述：
把数组转换成链表后输出交换位置后的链表
示例1
输入： 4 2 3 4 5 输出： 3 2 5 4
💡解决如下：
#include <stdio.h>
#include <stdlib.h>
//链表定义
typedef struct LNode {
int data;
struct LNode* next;
} LNode;
//创建链表
void CreateLNode(LNode** L, int a[], int n) {
LNode* s, *r;
*L = (LNode*)malloc(sizeof(LNode));
r = *L;
for (int i = 0; i < n; i++) {
s = (LNode*)malloc(sizeof(LNode));
s->data = a[i];
r->next = s;
r = s;
}
r->next = NULL;
}
//链表输出
void DispLNode(LNode** L) {
LNode* p = *L;
while (p->next != NULL) {
printf("%d ", p->next->data);
p = p->next;
}
}
//链表交换
void SwapLNode(LNode **L){
LNode *p=*L,*q=(*L)->next,*s;//p:头节点，q:首结点
//1.交换前两个节点的值
int t=q->next->data;
q->next->data=q->data;
q->data=t;
//2.交换最后两个节点值分成2.1定位倒数第二个节点 2.2交换值
while(p->next->next!=NULL){
p=p->next;
}
q=p;//故技重施哈哈
t=q->next->data;
q->next->data=q->data;
q->data=t;
}
int main() {
int a[100];
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
LNode* L;
CreateLNode(&L, a, n);
SwapLNode(&L);
DispLNode(&L);
return 0;
}😎2.3 牛牛的单链表求和
描述
牛牛输入了一个长度为 n 的数组，他想把这个数组转换成链表，链表上每个节点的值对应数组中一个元素的值，然后遍历链表并求和各节点的值。
输入描述：
第一行输入一个正整数 n ，表示数组的长度。
第二行输入 n 个正整数，表示数组中各个元素的值。
输出描述：
把数组转换成链表然后对其求和并输出这个值。
示例1
输入： 5 5 2 3 1 1 输出： 12
💡解决如下：
#include <stdio.h>
#include <stdlib.h>
//链表定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
//创建链表
void CreateLNode(LNode **L,int a[],int n){
LNode *s,*r;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//链表求和
int DispLNode(LNode **L){
LNode *p=*L;
int sum=0;
while (p->next!=NULL) {
sum+=p->next->data;
p=p->next;
}
return sum;
}
int main(){
int a[100];
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
LNode *L;
CreateLNode(&L, a, n);
printf("%d\n",DispLNode(&L));
return 0;
}😎2.4 牛牛的双链表求和
描述
牛牛输入了两个长度相同的数组分别是 a 和 b ，然后把数组 a 和 b 转换成链表 a 和链表 b 。把链表 a 中的全部值按顺序加到链表 b 中。
输入描述：
第一行输入一个正整数 n ，表示数组的长度。
第二行和第三行分别输入 n 个正整数，表示数组 a 和 数组 b 的值。
输出描述：
把数组 a 和数组 b 转换成链表，然后把链表 a 中的值加到链表 b 中，然后输出加和后的链表。
示例1
输入： 5 5 4 2 1 3 2 4 5 8 9 输出： 7 8 7 9 12
💡解决如下：
#include <stdio.h>
#include <stdlib.h>
//链表定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
//创建链表
void CreateLNode(LNode **L,int a[],int n){
LNode *s,*r;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//链表输出
void DispLNode(LNode **L){
LNode *p=*L;
while (p->next!=NULL) {
printf("%d ",p->next->data);
p=p->next;
}
}
//两个链表相加
void AddLNode(LNode **L1,LNode **L2){
LNode *p1=*L1,*p2=*L2;
while(p1->next!=NULL){
p2->next->data+=p1->next->data;
p1=p1->next;
p2=p2->next;
}
}
int main(){
int a[100],b[100];
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(int i=0;i<n;i++){
scanf("%d",&b[i]);
}
LNode *L1,*L2;
CreateLNode(&L1, a, n);
CreateLNode(&L2, b, n);
AddLNode(&L1, &L2);
DispLNode(&L2);
return 0;
}😎2.5 牛牛的链表删除
描述
牛牛从键盘输入了一个长度为 n 的数组，把这个数组转换成链表然后把链表中所有值是 x 的节点都删除。
输入描述：
第一行输入两个正整数 n 和 x 表示数组的长度和要删除的链表节点值 x 。
第二行输入 n 个正整数表示数组中每个元素的值。
输出描述：
把数组转换成链表然后删除所有值是 x 的节点，删除后输出这个链表。
示例1
输入： 5 3 1 5 3 2 3 输出： 1 5 2
💡解决如下：
#include <stdio.h>
#include <stdlib.h>
//链表定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
//创建链表
void CreateLNode(LNode **L,int a[],int n){
LNode *s,*r;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//链表输出
void DispLNode(LNode **L){
LNode *p=*L;
while (p->next!=NULL) {
printf("%d ",p->next->data);
p=p->next;
}
}
//删去对应值的链表元素
void DelLNode(LNode **L,int e){
LNode *p=*L;
while (p->next!=NULL) {
if(p->next->data==e){
p->next=p->next->next;
}
p=p->next;
}
}
int main(){
int a[100];
int n,e;
scanf("%d %d",&n,&e);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
LNode *L;
CreateLNode(&L, a, n);
DelLNode(&L, e);
DispLNode(&L);
return 0;
}😎2.6 牛牛的链表添加节点
描述
牛牛输入了一个长度为 n 的数组，他把这个数组转换成链表并在第 i 个节点的后面添加一个值为 i 的新节点
输入描述：
第一行输入两个正整数分别是 n 和 i ，表示数组的长度、需要添加节点的位置和节点的值
第二行输入 n 个正整数表示数组中每个元素的值。
输出描述：
把数组转换成链表并在第 i 个节点后的添加一个新节点值，新节点的值是 i。
示例1
输入： 5 3 5 4 8 6 3 输出： 5 4 8 3 6 3
💡解决如下：
#include <stdio.h>
#include <stdlib.h>
//链表定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
//创建链表
void CreateLNode(LNode **L,int a[],int n){
LNode *s,*r;
*L=(LNode *)malloc(sizeof(LNode));
r=*L;
for(int i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
//链表输出
void DispLNode(LNode **L){
LNode *p=*L;
while (p->next!=NULL) {
printf("%d ",p->next->data);
p=p->next;
}
}
//插入
void InsertLNode(LNode **L,int i,int e){
LNode *p=*L,*s,*q;
for(int j=0;j<i && p->next!=NULL;){
p=p->next;
j++;
}
if(p==NULL){
printf("error!\n");
}
else{
s=(LNode *)malloc(sizeof(LNode));
s->data=e;
q=p->next;
s->next=q;
p->next=s;
}
}
int main(){
int a[100];
int n,e;
scanf("%d %d",&n,&e);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
LNode *L;
CreateLNode(&L, a, n);
InsertLNode(&L, e, e);
DispLNode(&L);
return 0;
}🌐第三部分 结构体与类篇
😎3.1 KiKi定义电子日历类
描述
KiKi学习了面向对象技术，学会了通过封装属性（变量）和行为（函数）定义类，现在他要设计一个电子日历类TDate。
它有3个私有数据成员：Month,Day,Year和若干个公有成员函数，要求：
（1）带有默认形参值的构造函数，默认值为0, 0, 0；
（2）输出日期函数，用“日/月/年”格式输出日期；
（3）设置日期函数，从键盘输入年、月、日。输入描述：
一行，三个整数，用空格分隔，分别表示年、月、日。
输出描述：
一行，用“日/月/年”格式输出日期。
示例1
输入： 2019 12 30 输出： 30/12/2019
💡解决如下：
#include <iostream>
using namespace std;
class TDate{
private:
int Month;
int Day;
int Year;
public:
//带有默认形参值的构造函数，默认值为0, 0, 0
TDate(int Year=0,int Month=0,int Day=0){}
void SetValue(int a,int b,int c){
Year=a;
Month=b;
Day=c;
}
void Disp(){
cout<<Day<<"/"<<Month<<"/"<<Year<<endl;
}
};
int main(){
TDate today;
int Year, Month, Day;
cin>>Year>>Month>>Day;
today.SetValue(Year,Month,Day);
today.Disp();
return 0;
}😎3.2 KiKi设计类继承
描述
KiKi理解了继承可以让代码重用，他现在定义一个基类shape，私有数据为坐标点x,y, 由它派生Rectangle类和Circle类，它们都有成员函数GetArea()求面积。派生类Rectangle类有数据：矩形的长和宽；派生类Circle类有数据：圆的半径。Rectangle类又派生正方形Square类，定义各类并测试。输入三组数据，分别是矩形的长和宽、圆的半径、正方形的边长，输出三组数据，分别是矩形、圆、正方形的面积。圆周率按3.14计算。
输入描述：
输入三行，
第一行为矩形的长和宽，
第二行为圆的半径，
第三行为正方形的边长。
输出描述：
三行，分别是矩形、圆、正方形的面积。
示例1
输入： 7 8 10 5 输出： 56 314 25
💡解决如下：
#include <iostream>
using namespace std;
class Shape{//基类
private:
int x,y;
public:
virtual double GetArea() const = 0;
};
class Rectangle :public Shape{
private:
int l,w;
public:
//需要提供一个默认构造函数，因为square继承后需要调用Rectangle的构造，不提供则出错
Rectangle(){}
Rectangle(int l1,int l2){
l=l1;
w=l2;
}
virtual double GetArea() const {
return l*w;
}
void Disp(){
cout<<GetArea()<<endl;
}
};
class Circle:public Shape{
private:
int r;
public:
Circle(int l){
r=l;
}
double GetArea() const{
return 3.14*r*r;
}
void Disp(){
cout<<GetArea()<<endl;
}
};
class Square : public Rectangle{
private:
int len;
public:
Square(int l){
len=l;
}
double GetArea() const{
return len*len;
}
void Disp(){
cout<<GetArea()<<endl;
}
};
int main(){
int x,y;
cin>>x>>y;
int r;
cin>>r;
int len;
cin>>len;
Rectangle rectangle(x,y);
rectangle.Disp();
Circle circle(r);
circle.Disp();
Square square(len);
square.Disp();
return 0;
}😎3.3 牛牛的书
描述
牛牛正在买书，每本书都有名字和价格，牛牛想把书按照价格升序排序。
输入描述：
第一行输入一个正整数 n ，表示书的数量。
后续每行都输入一个字符串 str 和一个正整数 p 表示书价格。
输出描述：
把书名按照价格升序输出。
示例1
输入： 3 TheNowcoder 100 Abook 20 BBook 300 输出： Abook TheNowcoder BBook
💡解决如下：
#include <iostream>
#include <string>
using namespace std;
struct Books{//C++不用typedef也可以直接使用Books
string name;
int price;
};
//输出
void DispBooks(Books books[],int n){
for(int i=0;i<n;i++){
cout<<books[i].name<<endl;
}
}
//排序
void Sort(Books books[],int n){
for(int i=0;i<n-1;i++){
for(int j=0;j<n-1-i;j++){
if(books[j].price>books[j+1].price){
string str=books[j].name;
int t=books[j].price;
books[j].name=books[j+1].name;
books[j].price=books[j+1].price;
books[j+1].name=str;
books[j+1].price=t;
}
}
}
}
int main(){
Books books[100];
int n;cin>>n;
for(int i=0;i<n;i++){
cin>>books[i].name>>books[i].price;
}
Sort(books, n);
DispBooks(books, n);
return 0;
}
😎3.4 牛牛的平面向量
描述
牛牛有 n 个平面向量 (x1,y1) ，牛牛把这几个向量相加并输出这个向量的值。
输入描述：
第一行输入一个正整数 n
后续 n 行每行输入两个正整数分别是 x 和 y。
输出描述：
输出所有的向量相加的结果
示例1
输入： 3 1 2 2 1 3 3 输出： 6 6
💡解决如下：
#include <iostream>
using namespace std;
struct Shape{
int x,y;
};
//输出
void Disp(Shape shape){
cout<<shape.x<<" "<<shape.y<<endl;
}
//多个相加
Shape AddShape(Shape shape[],int n){
Shape newshape;
newshape.x=0;
newshape.y=0;
for(int i=0;i<n;i++){
newshape.x+=shape[i].x;
newshape.y+=shape[i].y;
}
return newshape;
}
int main() {
int n;
cin>>n;
Shape shape[100];
for(int i=0;i<n;i++){
cin>>shape[i].x>>shape[i].y;
}
Disp(AddShape(shape,n));
return 0;
}
😎3.5 牛牛的时钟
描述
牛牛在午夜12点（0点0分0秒）正在思考，在 t 秒之后是什么时间。他思考了 n 次这个问题。
输入描述：
第一行输入一个正整数 n。
第二行输入 n 个正整数 t ，表示 t 秒之后。
输出描述：
输出 n 行，每行输出 t 秒之后的时间。
示例1
输入： 4 60 61 1 2 输出： 0 1 0 0 2 1 0 2 2 0 2 4
💡解决如下：
#include <iostream>
using namespace std;
//计算过去的时间
void Disp(int a[],int n){
int sum=0;
int h=0,m=0,s=0;
for(int i=0;i<n;i++){
sum+=a[i];
h=sum/3600;
m=(sum-h*3600)/60;
s=sum%60;
cout<<h<<" "<<m<<" "<<s<<endl;
}
}
int main() {
int n;
cin>>n;
int a[100];
for(int i=0;i<n;i++){
cin>>a[i];
}
Disp(a, n);
return 0;
}
😎3.6 结构体简单使用
描述
设计一个学生结构体，该结构体具有三个成员，分别是：姓名name、年龄age、身高height。
键盘依次输入姓名、年龄和身高数据，将数据保存到学生结构体变量上，并输出学生信息。
输入描述：
键盘依次输入学生的姓名name、年龄age、身高height
输出描述：
输出学生的信息，例如：
张三 20 182.5
示例1
输入： 张三 20 182.5 输出： 张三 20 182.5
💡解决如下：文章来源：https://www.toymoban.com/news/detail-773409.html
#include <iostream>
#include <string>
using namespace std;
struct Student{
string name;
double age;
double height;
//构造函数
Student(){}
Student(string n,double a,double h){
name=n;
age=a;
height=h;
}
};
void Disp(Student s){
cout<<s.name<<" "<<s.age<<" "<<s.height<<endl;
}
int main() {
string name;
double age,height;
cin>>name;
cin>>age;
cin>>height;
Student student(name,age,height);
Disp(student);
return 0;
}
文章来源地址https://www.toymoban.com/news/detail-773409.html
到了这里，关于【编码狂想】指针航行，链表魔法，解锁结构体和类的编程幻境的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![【数据结构】[LeetCode138. 复制带随机指针的链表]](https://imgs.yssmx.com/Uploads/2024/02/445370-1.png)
![【LeetCode】数据结构题解（9）[复制带随机指针的链表]](https://imgs.yssmx.com/Uploads/2024/02/672298-1.png)
