剑指offer中一些有关数组和字符串操作的代码实现和扩充

最新推荐文章于 2023-06-12 22:16:17 发布
最新推荐文章于 2023-06-12 22:16:17 发布
阅读量354 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bixiwen_liu/article/details/75244637
版权

本文主要介绍剑指offer中一些有关数组和字符串操作的C语言代码实现和扩充。

#include "vector"
#include "stdio.h"
#include "stdlib.h"
#include <algorithm>
#include <iostream>
#include<math.h>
using namespace std;

//******************--求指针数组的长度--*********************
int main31()
{
	char *p[]={"zsxdzx","sdf","ZAcds"};
	//int s = sizeof(p)/sizeof(p[0]);
	int s = sizeof(p)/sizeof(*p);
	printf("%d\n",s);
	printf("%c\n",p[1][0]);
	return 0;
}
//******************--快速排序--*********************
void Swap(int *num1, int *num2)
{
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

int Partition(int data[], int length, int start, int end)
{
	if(data == NULL || length <=0 || start <0 || end >= length)
		return -1;

	int index = (rand() % (end-start+1))+ start;
	Swap(&data[index],&data[end]);

	int small = start-1;
	for (index=start;index<end;index++)
	{
		if(data[index]<data[end])
		{
			++small;
			if(index != small)
				Swap(&data[index],&data[small]);
		}
	}
	++small;
	Swap(&data[index],&data[small]);

	return small;
}
void QuickSort(int data[], int length, int start, int end)
{
	if(data == NULL || length <=0 || start <0 || end >= length)
		return;
	int index = Partition(data,length,start,end);

	if(index>start)
		QuickSort(data,length,start,index-1);
	if(index<end)
		QuickSort(data,length,index+1,end);
	
}
int main32()
{
	int number[] = {3,6,78,9,1,2,4,12,3};
	int startNum = 0;
	int endLen = sizeof(number)/sizeof(number[0]);
	QuickSort(number, endLen, startNum, endLen-1);
	//int num1=0, num2 = 10;
	//Swap(&num1,&num2);
	//printf("%d,%d\n",num1,num2);
	for (int i=0; i<endLen;i++)
		printf("%d\t",number[i]);
	return 0;
}

//******************--年龄排序--*********************
void SortAge(int ages[], int length)
{
	if(ages == NULL || length <=0)
		return;

	const int oldAge = 99;
	int timeOfAge[oldAge+1];

	for(int i=0;i<=oldAge;i++)
		timeOfAge[i] = 0;

	for(int i=0; i<length; i++){
		int age = ages[i];
		if(age <=0 || age >oldAge)
			throw std::exception("input age wrong!");
		timeOfAge[age]++;

	}

	int index=0;
	for (int i=0;i<=oldAge;i++)
	{
		for(int j=0;j<timeOfAge[i];j++){
			ages[index] = i;
			index++;
		}

	}

}

int main33()
{
	int age[] = {15,16,72,25,21,23,22,21,22,21,23,25,29,30,26};
	int length = sizeof(age)/sizeof(age[0]);
	SortAge(age,length);
	for (int i=0; i<length;i++)
		printf("%d, ",age[i]);
	return 0;
}
//******************--字符串中去除重复的字符--改变原字符顺序*********************
char* SortString(char *str, int length){
	if(str == NULL || length <= 0)
		return NULL;

	const int numbers = 52;
	int mychar[numbers+1];
	
	for(int i=0;i<=numbers;i++)
		mychar[i] = 0;

	for(int i=0; i<length-1; i++){
		int age = str[i]-'A';
		if(age <0 || (age >26 && age<32) || age > 58){
			printf("input age wrong!");
			return NULL;
		}
		if (age >=32)
			age -= 6;
		mychar[age]++;
	}

	int index = 0;
	for (int i=0;i<=numbers;i++)
	{
		if (mychar[i] == 1)
		{
			if (i<26)
				str[index] = i+'A';
			else if(i<52)
				str[index] = i+'A'+6;
			index++;
		}
	}
	for(int i=index;i<length;i++)
		str[i] = '\0';

	return str;
}

int main341()
{
	char str[] = "abcabsdasdaAAA";
	int length = sizeof(str)/sizeof(str[0]);
	char* mystr = SortString(str,length);
	if(mystr == NULL)
		return -1;
	int length2 = strlen(mystr);
	for (int i=0; i<length2;i++)
		printf("%c",mystr[i]);
	printf("\n");
	
	return 0;
}
//******************--字符串中去除重复的字符--未改变原字符顺序*********************
char* SortString2(char *str, int length){  
	if(str == NULL || length <= 0)  
		return NULL;  

	const int numbers = 26;  
	int mychar[numbers];  

	char* tmp = (char*)malloc(sizeof(char)*length);
	memset(tmp,0,length);

	for(int i=0;i<numbers;i++)  
		mychar[i] = 0;  

	for(int i=0; i<length-1; i++){  
		tmp[i] = str[i];
		int s = str[i]-'a';  
		if(s <0 || s > 25){  
			printf("input age wrong!");  
			return NULL;  
		}  
		mychar[s]++;  
	}  

	int index = 0; 
	for (int i=0;i<length;i++)  
	{  
		if(mychar[str[i]-'a'] == 1){
			str[index] = tmp[i];
			index++;
		}
	}  
	for(int i=index;i<length;i++)  
		str[i] = '\0';  

	return str;  
}  

int main342()  
{  
	char str[] = "abcabsdasdathfgr";  
	int length = sizeof(str)/sizeof(str[0]);  
	char* mystr = SortString2(str,length);  
	if(mystr == NULL)  
		return -1;  
	int length2 = strlen(mystr);  
	for (int i=0; i<length2;i++)  
		printf("%c",mystr[i]);  
	printf("\n");  

	return 0;  
}




//******************--求旋转数组中的最小值--*********************
int minNum(int *numbers, int length)
{
	if(numbers == NULL || length <=0)
		return -1;
	int res = numbers[0];
	for(int i=1;i<length;i++){
		if(res > numbers[i])
			res = numbers[i];
	}
	return res;
}

int Min(int *numbers, int length)
{
	if(numbers == NULL || length <=0)
		return -1;

	int index1 = 0;
	int index2 = length-1;
	int mid = index1;

	while(numbers[index1]>=numbers[index2])
	{
		if(index2-index1 == 1){
			mid = index2;
			break;
		}

		mid = (index1+index2)/2;

		if(numbers[index1]==numbers[mid] && numbers[index2] == numbers[mid])
			return minNum(numbers,length);

		if(numbers[mid]>numbers[index1])
			index1 = mid;
		else if(numbers[mid] <= numbers[index2])
			index2 = mid;
	}
	return numbers[mid];
}
int main36()
{
	int numbers[] = {1,1,1,0,1};
	int length = sizeof(numbers)/sizeof(numbers[0]);

	int res = 0;
	res = Min(numbers, length);
	printf("%d\n",res);
	return 0;
}
//******************--动态规划问题---剪绳子问题--*********************

int maxProductAfterCutting_solution(int num)
{
	if(num<2)
		return 0;
	if(num==2)
		return 1;
	if(num==3)
		return 2;

	int* product = new int[num+1];
	product[0] = 0;
	product[1] = 1;
	product[2] = 2;
	product[3] = 3;

	int max = 0;
	for (int i=4;i<=num;i++)
	{
		max = 0;
		for (int j=1;j<=i/2;j++)
		{
			int prod = product[j]*product[i-j];
			if(prod>max)
				max = prod;
			//product[i] = max;
		}
		product[i] = max;
	}
	max = product[num];
	return max;
}

//******************-贪心算法---剪绳子问题--*********************
int maxProductAfterCutting_solution2(int num)
{
	if(num<2)
		return 0;
	if(num==2)
		return 1;
	if(num==3)
		return 2;

	int timeOf3 = num/3;

	if (num%3 == 1)
		timeOf3--;
	int timeOf2 = (num-3*timeOf3)/2;
	return (int)(pow((double)3,timeOf3)) * (int)(pow((double)2,timeOf2));
}

int main35()
{
	int num = 10;
	int res = 0;
	res = maxProductAfterCutting_solution(num);
	printf("%d\n",res);

	int res2 = maxProductAfterCutting_solution2(num);
	printf("%d\n",res2);

	return 0;

}



//******************--求数字对应的二进制中1的个数--*********************
//方法一
int NumberOf1(int num)
{
	int count = 0;

	unsigned int flag = 1;
	while(flag){
		if(num & flag)
			count ++;
		flag = flag << 1;
	}
	return count;
}
//方法二
int NumberOf1_low(int num)
{
	int count = 0;
	while(num){
		count ++;
		num = (num-1)#
	}
	return count;
}
//******************--判断一数字是否为2的次方--*********************
bool PowOf2(int num)
{
	if(num&(num-1))
		return false;
	else
		return true;
}
//******************-求一个数到另一个数改变的步数-*********************
int changeStride(int num1, int num2)
{
	//求一个数到另一个数改变的步数，先将两个数异或，再求结果中1的个数
	return NumberOf1(num1^num2);

}

int main37()
{
	int number = 8;
	int res = 0;
	res = NumberOf1(number);
	printf("%d\n",res);

	int res2 = NumberOf1_low(number);
	printf("%d\n",res2);

	bool res3 = PowOf2(number);
	printf("%d\n",res3);

	int res4 = changeStride(10,13);
	printf("%d\n",res4);

	return 0;
}

//******************-数值的整数次方-*********************
//方法一
double PowerWithUnsignedExponent(double base, int exponent)
{
	double res = 1.0;
	for (int i=0;i<exponent;i++)
		res *= base;
	return res;
}
//方法二
double PowerWithUnsignedExponent2(double base, int exponent)
{
	if(exponent==0)
		return 1.0;
	if(exponent == 1)
		return base;
	double res = PowerWithUnsignedExponent2(base, exponent>>1);
	res *= res;
	if((exponent & 0x1) == 1)
		res *= base;
	return res;
}
double Power(double base, int exponent)
{
	double res = 0;

	if(abs(base-0.0)<1e-6 && exponent<0)
		return 0.0;

	unsigned int absExponent = (unsigned int)exponent;
	if(exponent <0)
		absExponent = (unsigned int)(-exponent);
	//res = PowerWithUnsignedExponent(base,absExponent);
	res = PowerWithUnsignedExponent2(base,absExponent);
	if(exponent<0)
		res = 1.0/res;
	return res;
}
int main38()
{
	double base = 2;
	int exponent = -2;
	double res = 0;

	res = Power(base, exponent);
	printf("%lf\n",res);

	return 0;
}

//******************-从1打印到最大的n位数-*********************

void PrintNumber(char* number)
{
	if(number == NULL)
		return;
	bool flag = false;
	int len = strlen(number);

	for(int i=0;i<len;i++)
	{
		if(!flag &&number[i] != '0')
			flag = true;
		if(flag)
			printf("%c",number[i]);
	}
	printf(", ");
}
//方法一
bool Increment(char* number)
{
	if(number==NULL)
		return false;
	bool nFlow = false;
	int nTakeOver = 0;
	int len = strlen(number);

	for (int i=len-1;i>=0;i--)
	{
		int nSum = number[i] - '0' + nTakeOver;
		if(i == len-1)
			nSum++;
		if(nSum>=10){
			if(i==0){
				nFlow = true;
				//return true;
			}
			else{
				nSum -= 10;
				nTakeOver = 1;
				number[i] = '0' + nSum;
			}
		}
		else{
			number[i] = '0' + nSum;
			break;
		}
	}
	return nFlow;
}

void Print1ToMaxOfN(int n)
{
	if(n<=0)
		return;
	char *number = new char[n+1];
	memset(number,'0',n);
	number[n] = '\0';

	while(!Increment(number)){
		PrintNumber(number);
	}

	delete []number;
}
//方法二：递归

void Print1ToMaxOfN2_Recu(char* number, int n, int index)
{
	if(index == n-1){
		PrintNumber(number);
		return;
	}
	for(int i=0;i<10;i++)
	{
		number[index+1] = i + '0';
		Print1ToMaxOfN2_Recu(number,n,index+1);
	}
}
void Print1ToMaxOfN2(int n)
{
	if(n<=0)
		return;
	char* number = new char[n+1];
	number[n] = '\0';

	for(int i=0;i<10;i++)
	{
		number[0] = i + '0';
		Print1ToMaxOfN2_Recu(number,n,0);
	}

	delete []number;
}
int main39()
{
	Print1ToMaxOfN(2);
	printf("\n");
	Print1ToMaxOfN2(2);
	return 0;
}

int GetNumberOfK2(int *a,int start, int end, int i)
{
	if(start == end)
		return a[start];

	int index = Partition(a,end+1,start,end);
	int k = index - start;
	if(i == k)
		return a[index];
	else if(i<k)
		return GetNumberOfK2(a, start, index-1, i);
	else
		return GetNumberOfK2(a, index+1, end, i-k);

}
int GetNumberOfK(int *a,int start, int end, int k)
{
	if(start == end)
		return a[start];

	int index = Partition(a,end+1,start,end);
	while(index != k-1){
		if(index>k-1)
			index = Partition(a, end+1,start, index-1);
		else
			index = Partition(a, end+1,index+1, end);
	}
	return a[index];
}
int main390()
{
	int a[] = {1,4,78,1,2,46,34,24};
	int ret = GetNumberOfK2(a,0,7,5);
	printf("%d\n",ret);
	return 0;
}









 


                

        

        

    

  


    

      

        

            

              
                
                  Bixiwen_liu
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
对数值扩充成字符串用于自增ID用

				
			

			

				

					traysine的专栏
				

				

					02-09
					
					1016
					
				

			

		

		

			
				
对位数少记录多的字段特殊处理本文是自己的一些编程记录。场景：与外界数据联合需要一个单独的8位ID，由自己创建且不能重复，考虑到本身用户上百万加上往后的增量，普通的8位字符可能会不够用。联想到车牌号对于字符的处理，加上java本身的随机字符串不足以代表自增趋势，所以想出了以下的解决方案。解决方案：首先在数字自增的基础上加上ASCII的字符串自增，做到一位就能代表10+26+26=62个不同的ID，8位

			
		

	



                

              
                



	

		

			

				
					
剑指offer中的一些数组和字符串的操作的代码实现和扩充

				
			

			

				

					Bixiwen_liu的博客
				

				

					12-26
					
					132
					
				

			

		

		

			
				
本文主要介绍一些剑指offer中的#include "vector"
#include "stdio.h"
#include "stdlib.h"
#include 
#include 
#include
using namespace std;

//******************--求指针数组的长度--*********************
int main31()
{
	char 

			
		

	



                


  
              

                


	

		

			

				
					
剑指offer_数组-字符串-链表-树-栈和队列

				
			

			

				

					weixin_43271235的博客
				

				

					05-08
					
					188
					
				

			

		

		

			
				
前言：只作为回忆复习，java编写，代码一定要带注释，部分题目附上解题思路。
1、二维数组中的查找
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
public class Solution {
    public boolean Find(int target, int [][] array) {
        // 若array为null或者里面

			
		

	





	

		

			

				
					
1 剑指offer--数组--二维数组中的查找

				
			

			

				

					weixin_41563161的博客
				

				

					10-09
					
					309
					
				

			

		

		

			
				
二维数组中的查找

基础知识

1 数组和字符串是两种最基本的数据结构，它们用连续内存分别存储数字和字符

2 栈是一个与递归紧密相关的数据结构，

3 队列也与广度优先遍历算法紧密相关，

4 数组可以说是最简单的一种数据结构，它占据一块连续的内存并按照顺序存储数据。创建数组时，我们需要首先指定数组的容量大小，然后根据大...

			
		

	



		

			
		



	

		

			

				
					
Leetcode——数组和字符串

				
			

			

				

					Arashi_5的博客
				

				

					02-02
					
					2397
					
				

			

		

		

			
				
151.翻转字符串里的单词
给定一个字符串，逐个翻转字符串中的每个单词。
说明：


无空格字符构成一个 单词 。


输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。


如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
提示：


1 <= s.length <= 104


s 包含英文大小写字母、数字和空格 ’ ’


s 中 至少存在一个 单词


思路：

要原地进行翻转的话，就不能另外创建一个字符串来从后往前读取保存单词。
可以先将字符串整个翻

			
		

	





	

		

			

				
					
【leetcode刷题之路】剑指Offer（1）——字符串+链表+双指针

					
最新发布

				
			

			

				

					xtcc的博客
				

				

					06-12
					
					5341
					
				

			

		

		

			
				
利用双指针，定义pa和pb分别指向A和B的头节点，这里判断是否相交采用了一个非常有意思的方法，假设A和B相交节点前各有skipA和skipB个节点，而相交节点数为C，pa和pb同时开始遍历，如果pa遍历完了就指向headB，同理pb，那么到最后总会遍历相同次数，对于A：skipA+C+skipB，对于B：skipB+C+skipA，如果此时的节点一样的话，说明相交，否则说明都遍历到了各自的最后节点仍不相交，返回空指针。判断当前l1和l2的大小，如果l1较小，就从l1往后连接，并返回l1，同理l2。

			
		

	





	

		

			

				
					
剑指offer-04：字符串替换空格

				
			

			

				

					鸟恋旧林的博客
				

				

					08-06
					
					323
					
				

			

		

		

			
				
题目：实现一个函数，把字符串中的每个空格替换为”%20”。
题目背景：网络编程中URL参数中的特殊字符，如空格，#等需要转换为服务器可以识别的字符，转换规则是在%后面加上其ASCII码的两位十六进制表示。空格的ASCII码是32，十六进制为0x20，空格被替换为%20。首先：新字符串还是原字符串？若是新字符串，则分配可容纳空间，然后扫描原字符串，遇见空格特殊处理，其余字符原样复制。这没啥难度。若是原

			
		

	





	

		

			

				
					
剑指Offer（java实现）

					
热门推荐

				
			

			

				

					[ 25'h ]
				

				

					10-31
					
					1万+
					
				

			

		

		

			
				
剑指Offer（java实现）（包含个人思考）

			
		

	





	

		

			

				
					
力扣刷题day07|344反转字符串、541反转字符串II、剑指Offer05替换空格、151反转字符串里的单词、剑指Offer58-II左旋转字符串

				
			

			

				

					Skyc的学习博客
				

				

					09-29
					
					157
					
				

			

		

		

			
				
力扣刷题day07|344反转字符串、541反转字符串II、剑指Offer05替换空格、151反转字符串里的单词、剑指Offer58-II左旋转字符串

			
		

	





	

		

			

				
					
《牛客网 剑指Offer前20题》

				
			

			

				

					乌鸦大大
				

				

					03-11
					
					2056
					
				

			

		

		

			
				
《剑指Offer》三天刷完剑指offer前言知识面试题1：二维数组中的查找
三天刷完剑指offer
前言知识


优秀的程序员首先要有良好的基本功，基本功在面试编程环境体现在：编程语言、数据结构和算法。
  编程语言：以C语言为例，例如把const加在指针不同位置有什么区别。主要考察对编程语言掌握程度。
  数据结构：要熟练掌握链表、树、栈、队列和哈希表等数据结构，对链表的插入和删除节点了如指掌，...

			
		

	





	

		

			

				
					
《剑指Offer》从零单刷个人笔记整理（66题全）

				
			

			

				

					NJU_ChopinXBP的博客
				

				

					03-11
					
					1616
					
				

			

		

		

			
				
github:https://github.com/ChopinXBP/JZOffer_Babel/

《剑指Offer》以面试题为主，代码大都不长。比较适合两种人，第一种是新手入门，第二种是面前备战。

我就是以新手的姿态来刷这本书的，每一道题先按自己的思路写一遍，然后尽可能尝试所有的方法实现并调优，然后再把感想和总结以博客的形式进行记录和分享。

由于本人学习语言主Java，辅C++，所以每题...

			
		

	





	

		

			

				
					
LeetCode剑指offer58——“左旋字符串”+报错AddressSanitizer:heap-buffer-overflow

				
			

			

				

					qq_43531377的博客
				

				

					01-13
					
					313
					
				

			

		

		

			
				
leetcode——剑指offer58“左旋字符串”
【问】
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = “abcdefg”, k = 2
输出: “cdefgab”
【解】
char* reverseLeftWords(char* s, int n)
{
    int len = strlen(s);
    //另一

			
		

	





	

		

			

				
					
刷题笔记（剑指offer-67题，Java版）

				
			

			

				

					晋青杨
				

				

					08-25
					
					922
					
				

			

		

		

			
				
本文包括刷题的总体思想要义、以及剑指offer67题的全部题解

			
		

	





	

		

			

				
					
【怒撕剑指Offer】之「替换空格」

				
			

			

				

					厉兵秣码
				

				

					11-19
					
					443
					
				

			

		

		

			
				
【怒撕剑指Offer】系列旨在用最通俗易懂的语言与动画讲解算法，培养逻辑思维，让你在互联网面试过程中不再畏惧手撕算法。

1 题目描述
将字符串中的空格替换成"%20"。
输入：s = "We are happy."
输出："We%20are%20happy."

2 解题思路
有两种比较好的解决方法，第一种是直接开辟一个新的数组，然后从前向后遍历，依次将原字符串中的字符添加进数组中，如果遇到空格，则添加 %20 三个字符，这种方法的时间复杂度为 O(n)O(n)O(n)，因为开辟了新的空间，额外空间复杂.

			
		

	





	

		

			

				
					
C语言：结构体中一级指针和二级指针的创建与释放示例

				
			

			

				

					Bixiwen_liu的博客
				

				

					12-13
					
					4678
					
				

			

		

		

			
				
结构体结构体中一级指针和二级指针的创建与释放，以一个例子来说明，笔者这里自己敲得代码，虽然用C语言几年了，但是有的东西还是会遗忘。笔者敲代码过程中也是有bug出现的，经过调试也找到了bug所在，不得不说，巩固也是很重要的。而结构体作为C语言一部分也是很重要的，指针作为C语言的半壁江山也保持着其重要地位。学过C++或Java的都知道class（类），个人觉得结构体就像是class的一部分，不过里面不能放实现class的相关属性函数。代码不是很长，但里面有很多细节的考虑，特别是一级指针和二级指针的内存的申请和释

			
		

	





	

		

			

				
					
C语言：一级指针，二级指针，三级指针，指针数组，数组指针的综合示例

				
			

			

				

					Bixiwen_liu的博客
				

				

					12-13
					
					4456
					
				

			

		

		

			
				
本博客主要介绍一级指针，二级指针，三级指针，指针数组和数组指针的综合应用示例。下面简单介绍指针数组和数组指针的区别：

			
		

	





	

		

			

				
					
**a[3][4]，(**a)[3][4]， *(*a)[3][4]， *(*a[3])[4]等变量占用的内存

				
			

			

				

					Bixiwen_liu的博客
				

				

					08-27
					
					1835
					
				

			

		

		

			
				
今天发现一个一个关于二级指针的内存占用问题：**a[3][4]，(**a)[3][4]， *(*a)[3][4]， *(*a[3])[4]等变量占用的内存字节大小。

			
		

	





	

		

			

				
					
C++学习之友元函数和友元类

				
			

			

				

					Bixiwen_liu的博客
				

				

					03-11
					
					1434
					
				

			

		

		

			
				
一、前言

主要介绍C++中的友元函数和友元类。

二、友元函数

1.介绍

友元函数定义在类的外部，通过友元函数可以在类的外部修改类的私有属性，可理解为该函数是类的好朋友。类中，声明友元函数的关键字为friend，声明的位置和public或private 无关。具体示例代码如下。

2.示例代码


#include "iostream"
using namespace std;

class A
{
public:
	friend void modifyA(A *pA,int _a);//友元函数..

			
		

	





	

		

			

				
					
Python实现剑指offer题解：数组与字符串优化算法

				
			

			

				

					
				

			

		

		

			
				
通过这两个题目，学习者可以理解如何在实际编程中处理数组搜索和字符串操作，同时熟悉Python的基本数据结构和字符串操作特性。《剑指offer》提供了一个很好的平台，让开发者在解决实际问题的过程中提升算法理解和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
Bixiwen_liu

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

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

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

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值