【C/C++学院】0814-引用高级、引用高级增加/auto自动变量自动根据类型创建数据/Bool/Enum/newdelete全局/大数据乘法与结构体/函数模板与auto/宽字符本地化/inline

本文涉及的产品
云原生大数据计算服务MaxCompute,500CU*H 100GB 3个月
云原生大数据计算服务 MaxCompute,5000CU*H 100GB 3个月
简介: <p></p> <h2><span style="font-family:宋体; font-size:16pt">引用高级、引用高级增加</span><span style="font-family:宋体; font-size:16pt"></span></h2> <pre name="code" class="cpp">#include<iostream>#incl

引用高级、引用高级增加

#include<iostream>
#include<stdlib.h>
//	int a[10]
//  int (&ra)[10]
//   int a[2][5]
//   int (&ra)[2][5]
void main1()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int(&ra)[10](a);//引用就是给原来的变量有一个别名同一个地址
	int  i = 0;
	for (auto data: ra)//C++11的循环
	{
		data = i + 5;
		std::cout << data << std::endl;

	}
	std::cout << a << ra << std::endl;
	std::cout << &a << &ra << std::endl;

	system("pause");
}

void main2()
{
	int a[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int(&ra)[2][5](a);//引用就是给原来的变量有一个别名同一个地址
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			std::cout << " " << ra[i][j];
		}
		std::cout << "\n";
	}

	std::cout << a << ra << std::endl;
	std::cout << &a << &ra << std::endl;

	system("pause");	
}

int jia(int a, int b)
{
	return a + b;
}

int jian(int a, int b)
{
	return a - b;
}

void change(int(* & rp)(int,int))
{
	rp = jian;
}

void main3()
{
	int(* p)(int a, int b)(jia);
	std::cout << p(1, 2) << std::endl;
	//int(*&rp)(int a, int b)(p);//引用函数指针
	//rp=jian;//()仅仅适用于初始化

	change(p);
	std::cout << p(1, 2) << std::endl;

	system("pause");
}

int(*& changep(int (*&rp)(int,int)))(int, int)
{
	rp = jian;
	return rp;
}

void main4()
{
	int(*p)(int a, int b)(jia);
	std::cout << p(1, 2) << std::endl;
	
	p = changep(p);

	std::cout << p(1, 2) << std::endl;

	system("pause");
}

void main5()
{
	//int *p[4];
	int a = 1, b = 2, c = 3;
	int *px[3] = { &a, &b, &c };
	//int && p [4] = {a,b,c };
	//引用数组是非法的
}

struct mystr 
{	
	int b;
	double a;
	char c;
	//代码区的函数不计入结构体的sizeof
	void go()
	{
		std::cout << "123456789" << std::endl;
	}
};

class MyClass
{
	char &  a;
	char &  b;
	char & c;//引用的本质是指针,直接sizeof引用,就是求引用的数据大小
	//引用变量占据4个字节
};


void main6()
{
	int num = 10;
	int & rnum(num);
	double db = 10.9;
	double & rdb(db);//直接作用引用的变量

	std::cout << sizeof(rnum) << std::endl;
	std::cout << sizeof(rdb) << std::endl;
	std::cout << sizeof(MyClass) << std::endl;
	system("pause");
}
int  getdata(int && num)//右值引用,节约内存拷贝,内存优化所必须
{
	std::cout << num << std::endl;
	num += 10;
	return num;
}

void  main7()
{
	int a = 5;
	int b = 4;

	std::cout << getdata(a+1) << std::endl;

	system("pause");
}

//左值,一般可以取地址就是左值
//右值某些情况可以,某些情况不可以
void main8()
{
	int a = 3;
	int b = a + 1;//右值->左值
	std::cout << getdata(std::move(a) ) << std::endl;
	//std::move将左值转换为右值,C++11
}

void main9()
{
	//const int num(6);
	char str[10]("hello");//限定字符串不被修改
	const char *pc(str);//指向常量的指针限定了指向的数据无法修改,+1,+2,+3
	str[3] = 'x';//可以,
	//pc[3] = 'y';
	//*(pc + 3) = 'y';
	pc = "world";

	system("pause");
}

void main10()
{
	char str[10]("hello"); 
	const char(&rstr)[10](str);//常量引用
	const char(&rrstr)[10](rstr);//引用可以给另一个引用初始化
	str[4] = 'X';
	//rstr[4] = 'Y';

}

void  main11()
{

	int(*p)(int a, int b)(jia);
	std::cout << p(1, 2) << std::endl;
	int(* const &rp)(int a, int b)(p);//引用函数指针
	//rp=jian;//()仅仅适用于初始化
}

auto自动变量自动根据类型创建数据

#include <iostream>
#include<stdlib.h>

void main()
{
	double db = 10.9;
	double *pdb = &db;
	auto num = pdb;//通用传入接口
	std::cout << typeid(db).name() << std::endl;
	std::cout << typeid(num).name() << std::endl;
	std::cout << typeid(pdb).name() << std::endl;
	//typeid(db).name()  db2;
	decltype(db) numA(10.9);//通用的备份接口
	std::cout << sizeof(numA) <<"    "<< numA << std::endl;

	system("pause");
}

Bool

#include<iostream>
#include<stdlib.h>

void main()
{
	bool bl = (1 && 1) || 2 || (-1 && 0);
	std::cout << typeid(bl).name() << std::endl;
	std::cout << bl << std::endl;
	decltype(bl) bt(1 + 2 * 3 - 4 && 3 + 2 || -1);
	std::cout << bt << std::endl;
	system("pause");

}

Enum

C中为弱类型,不做类型检查。而c++为强类型,要求更加严格。

Enum.c

#include <stdio.h>

enum color{ red=11 ,yellow,green,white};

void main()
{
	enum color color1;
	color1 = 18;//不注重数据类型
	color1 = red;
	printf("%d", red);
	printf("\n%d", yellow);
	printf("\n%d", green);

	getchar();
}

Enum.cpp

#include <iostream>
enum color:char{ red='a' , yellow, green, white };

void main()
{
	color mycolor = red;
	mycolor = yellow;
	//mycolor = 'A';//确保在枚举的范围的之内不出错
	mycolor = color::white;//新语法

	color mycolor1(red);
	color mycolor2(color::red);

	printf("%d,%c\n", red,red);
	printf("%d,%c\n", yellow,yellow);

	system("pause");
}

newdelete全局

#include<iostream>
#include<stdlib.h>
//全局的new  delete监视所有释放分配
//局部的new delete监视某个类的所有分配释放

void *operator new(size_t size)
{
	if (size == 0)
	{
		return 0;
	}
	void *p = malloc(size);
	std::cout << "全局被调用内存被分配"<<p<<std::endl;
	return p;
}

void  operator delete (void *p)
{
	std::cout << "全局被调用内存被释放" << p << std::endl;
	free(p);
}

void *operator new[](size_t size)
{
	return operator new(size);//每个对象挨个调用已经重载好的new,调用构造
}

void operator delete[](void*p)
{
	return operator delete(p);//每个对象挨个调用已经重载好的delete,调用析构
}

class tansheng
{
public:
	static int jishuqi;//静态
	int *p;
	int length;
public:
	tansheng()//构建的时候初始化
	{
		std::cout << "谭胜被创建" << std::endl;
	}
	~tansheng()//删除的时候释放内存
	{
		std::cout << "谭胜被销毁" << std::endl;
	}

	static void * operator new(size_t size)
	{
		jishuqi += 1;
		std::cout << "对象被创建" << std::endl;
		tansheng *ptemp = ::new tansheng;//劫持
		return ptemp;
	}

	static void * operator new[](size_t size)
	{		
		std::cout << "对象数组被创建" << std::endl;
		return  operator  new(size);
	}	

	static void  operator delete(void *p)
	{
		jishuqi -= 1;
		std::cout << "对象被销毁" << std::endl;
		::delete p;//::全局
	}

	static void  operator delete[](void *p)
	{
		std::cout << "对象数组被销毁" << std::endl;
		return  operator  delete(p);
	}
};

int tansheng::jishuqi = 0;

void mai01n()
{
	//int *p = new int[10];
	//delete[]p;

	tansheng *p1 = new tansheng[5];
	delete  []p1;

	system("pause");
}

void main()
{
	int  *p = new int(8);
	delete p;

	system("pause");
}

大数据乘法与结构体

#define   _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
#include<string.h>

//C语言声明变量需要加上stuct
//C语言结构内部不可以有函数
//C语言结构体没有公有,私有,继承

struct MyStruct
{
	int num1;
	int num2;
};

struct  MyStruct MyStruct1;

/// 加法,减法
/// 1234.567 ×12345.987
/// 15K+  除法,

void getbigdata(char *dataa,char* datab)
{
	int lengtha = strlen(dataa);
	int lengthb = strlen(datab);
	int *pres = (int *)malloc(sizeof(int)*(lengtha + lengthb));
	memset(pres, 0, sizeof(int)*(lengtha + lengthb));//初始化
	//累乘
	for (int i = 0; i < lengtha;i++)
	{
		for (int j = 0; j < lengthb;j++)
		{
			pres[i+j+1]+=(dataa[i] - '0')*(datab[j] - '0');
		}
	}
	//进位
	for (int i = lengtha + lengthb-1;i>=0;i--)
	{
		if (pres[i]>=10)//进位
		{
			pres[i - 1] += pres[i] / 10;//进位
			pres[i] %= 10;//取出个位数
		}
	}

	int i = 0;
	while (pres[i]==0)
	{
		i++;//恰好不为0的位置
	}
	char *lastres = malloc(sizeof(char)*(lengtha + lengthb));
	int j;
	for (j = 0; j < lengtha + lengthb; j++, i++)
	{
		lastres[j] = pres[i] + '0';
	}
	lastres[j] = '\0';
	printf("last结果=%s",lastres);
}

void main()
{
	char str1[100] = { 0 };
	char str2[100] = { 0 };
	scanf("%s%s", str1, str2);
	printf("str1=%s,str2=%s", str1, str2);//打印结果
	getbigdata(str1, str2);
	
	system("pause");
}

#define   _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdlib.h>
#include<string.h>

//除了数据还有函数
struct bigdatacom
{
protected://内部私有
	char dataa[100];
	char datab[100];
public://公有公开
	void init(const char *str1, const char *str2)
	{
		std::cout << typeid(*this).name() << std::endl;        
		strcpy(this->dataa, str1);
		strcpy(this->datab, str2);
	}

	char * getbigdata()
	{
		int lengtha = strlen(dataa);
		int lengthb = strlen(datab);
		int *pres = (int *)malloc(sizeof(int)*(lengtha + lengthb));
		memset(pres, 0, sizeof(int)*(lengtha + lengthb));//初始化
		//累乘
		for (int i = 0; i < lengtha; i++)
		{
			for (int j = 0; j < lengthb; j++)
			{
				pres[i + j + 1] += (dataa[i] - '0')*(datab[j] - '0');
			}
		}
		//进位
		for (int i = lengtha + lengthb - 1; i >= 0; i--)
		{
			if (pres[i] >= 10)//进位
			{
				pres[i - 1] += pres[i] / 10;//进位
				pres[i] %= 10;//取出个位数
			}
		}
		int i = 0;
		while (pres[i] == 0)
		{
			i++;//恰好不为0的位置
		}
		char *lastres =(char*) malloc(sizeof(char)*(lengtha + lengthb));
		int j;
		for (j = 0; j < lengtha + lengthb; j++, i++)
		{
			lastres[j] = pres[i] + '0';
		}
		lastres[j] = '\0';
		return lastres;
		//printf("last结果=%s", lastres);
	}
};

struct myclass :public  bigdatacom //继承
{
	void coutstr()//新增
	{
		std::cout << this->dataa << this ->datab << std::endl;
	}
};

void main()
{
	myclass  class1;
	class1.init("12345", "1000");
	std::cout << class1.getbigdata() << std::endl;
	class1.coutstr();

	system("pause");
}

void main1()
{
	bigdatacom big1;//C++结构体可要可不要struct
	big1.init("123123", "456456");//调用内部函数
	std::cout << big1.getbigdata() << std::endl;

	system("pause");
}

函数模板与auto自动变量

函数模板

#include<stdlib.h>
#include<iostream>
#include<cstdarg>


//函数模板  可变参数
//参数至少要有一个是模板类型
template<typename NT>
NT sum(int count,NT data1 ...)//累加
{
	va_list arg_ptr;//参数列表的指针
	va_start(arg_ptr, count);//限定从count开始,限定多少个参数
	NT sumres(0);
	for (int i = 0; i < count;i++)
	{
		sumres += va_arg(arg_ptr, NT);
	}
	va_end(arg_ptr);//结束
	return sumres;
}

//T通用数据类型
template<typename T>
T MAX(T*p, const int n)
{
	T maxdata(p[0]);
	for (int i = 1; i < n; i++)	
	{
		if (maxdata < p[i])
		{
			maxdata = p[i];
		}
	}
	return maxdata;
}

int getmax(int *p, int n)
{
	int max(0);
	max = p[0];//假定第一个数位最大
	for (int i = 1; i < 10; i++)
	{
		if (max<p[i])//确保max>=p[i]
		{
			max = p[i];//
		}
	}
	return max;
}

double getmax(double *p, int n)
{
	double max(0);
	max = p[0];//假定第一个数位最大
	for (int i = 1; i < 10; i++)
	{
		if (max < p[i])//确保max>=p[i]
		{
			max = p[i];//
		}
	}
	return max;	
}


void main2()
{
	std::cout << sum(5,1,2,3,4,5) << std::endl;
	std::cout << sum(6, 1, 2, 3, 4, 5,6) << std::endl;
	std::cout << sum(7, 1, 2, 3, 4, 5, 6,7) << std::endl;
	std::cout << sum(7, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1) << std::endl;
	std::cout << sum(6, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1) << std::endl;
	system("pause");
}

void main1()
{
	double a[10] = {  2, 3, 4, 98, 77, 999.1, 87, 123, 0, 12 };
	int  b[10] = { 1, 2, 3, 4, 15, 6, 7, 8, 9, 10 };
	std::cout << MAX(a,10) << std::endl;
	std::cout << MAX(b, 10) << std::endl;

	system("pause");
}

Auto与函数模板

#include<stdlib.h>
#include<iostream>
/*
auto get(int num, double data)->decltype(num*data)
{

}
*/
//自动数据类型,根据实际推导出类型,
template<class T1,class T2>//根据类型获取类型
auto get(T1 data, T2 bigdata)->decltype(data *bigdata)
{
	return  data*bigdata;
}

//函数参数不允许使用自动变量
//int putnum(auto num)
//{
//
//}

void main()
{
	std::cout << typeid(get(12.0, 'A')).name() << std::endl;
	std::cout << get(12.0, 'A') << std::endl;
	std::cout << typeid(get(12, 'A')).name() << std::endl;
	std::cout << get(12, 'A') << std::endl;

	system("pause");
}

宽字符本地化

#include<iostream>
#include<stdlib.h>
#include<locale>

void main()
{
	setlocale(LC_ALL, "chs");//设置本地化
	wchar_t *p1 = L"123456123123qweqeqe";
	std::wcout << p1 << std::endl;
	wchar_t *p2 = L"北京123456";
	std::wcout << p2 << std::endl;

	system("pause");
}

inline 内联函数

#include <stdlib.h>
#include<iostream>

//替换
#define GETX3(N) N*N*N
//1+2*1+2*1+2
//函数

//inline只是对于编译器的建议
////一般情况下,我们对内联函数做如下的限制:
//(1) 不能有递归
//(2) 不能包含静态数据
//(3) 不能包含循环
//(4) 不能包含switch和goto语句
//(5) 不能包含数组
//若一个内联函数定义不满足以上限制,则编译系统把它当作普通函数对待。

inline int  getX3(int x);//内联函数,内部展开

inline int  getX3(int x)//类型安全
{
	return x*x*x;
}

template <class T>
inline T getX2(T x)//C++类型不匹配出错,不是单纯的替换
{
	return x*x;
}

void main()
{
	std::cout << GETX3(1 + 2) << std::endl;
	std::cout << getX3(1 + 2) << std::endl;
	std::cout << GETX3((1 + 2)) << std::endl;
	std::cout << GETX3((2.0 + 2)) << std::endl;

	system("pause");
}

CCPP不同

C特点

#include<stdio.h>
#include<stdlib.h>
int a;//C语言全局变量有声明与定义的差别
int a;
int a;
int a;
int a;
static int b;
static int b;

main()
{
	//3-3 ? system("calc") : system("mspaint");
	int num = 5 < 3?10:9;
	printf("%d", num);

	int a = 3;
	//(a = 3) = 4;
	int b = 5;
	//(a > b ? a : b)=2;
	//(++a)++
	register int numa=1;
	//&numa;

	system("pause");
}

void test(int a, double, int)//编译不能通过
{

}

C++

#include<stdio.h>
#include<iostream>
//C++检测到右值在内存有实体,自动转换为左值
//C 语言不会吧右值转换为左值

//C++全局变量没有声明与定义的差别
//静态全局变量也没有声明与定义的差别

//C++是强类型系统,函数返回值必须要有类型


//register C++编译器做了优化,检测到取地址,就不会把它放到寄存器
//register 可以取地址

int a;
//int a;
static int b;
//static int b;

//C++编译器 编译的宽泛,
//为了修改源代码,后面留下拓展
//占位,占位参数,
void test(int a, double, int)
{
	std::cout << a;
}

void   main1()
{
	int a = 3;
	(a = 3) = 4;
	int b = 5;
	(a > b ? a : b) = 2;
	(++a)++;
	//(a + 1)++;
	register int num(1);
	std::cout << &num<< std::endl;

	std::cout << a <<b<< std::endl;
	test(1, 2.9, 3);
	system("pause");
}
//detele以后尽量设置为NULL
//
void main2()
{
	int *p = new int;
	delete p;//防止重复删除
	p = NULL;
	delete p;
}

void  main()
{
	//int num;
	//文件重定向输入输出,网页重定向CGI
	char str[100] = { 0 };
	std::cin>>str;
	std::cout << str;
	system(str);
}




相关实践学习
基于MaxCompute的热门话题分析
本实验围绕社交用户发布的文章做了详尽的分析,通过分析能得到用户群体年龄分布,性别分布,地理位置分布,以及热门话题的热度。
SaaS 模式云数据仓库必修课
本课程由阿里云开发者社区和阿里云大数据团队共同出品,是SaaS模式云原生数据仓库领导者MaxCompute核心课程。本课程由阿里云资深产品和技术专家们从概念到方法,从场景到实践,体系化的将阿里巴巴飞天大数据平台10多年的经过验证的方法与实践深入浅出的讲给开发者们。帮助大数据开发者快速了解并掌握SaaS模式的云原生的数据仓库,助力开发者学习了解先进的技术栈,并能在实际业务中敏捷的进行大数据分析,赋能企业业务。 通过本课程可以了解SaaS模式云原生数据仓库领导者MaxCompute核心功能及典型适用场景,可应用MaxCompute实现数仓搭建,快速进行大数据分析。适合大数据工程师、大数据分析师 大量数据需要处理、存储和管理,需要搭建数据仓库?学它! 没有足够人员和经验来运维大数据平台,不想自建IDC买机器,需要免运维的大数据平台?会SQL就等于会大数据?学它! 想知道大数据用得对不对,想用更少的钱得到持续演进的数仓能力?获得极致弹性的计算资源和更好的性能,以及持续保护数据安全的生产环境?学它! 想要获得灵活的分析能力,快速洞察数据规律特征?想要兼得数据湖的灵活性与数据仓库的成长性?学它! 出品人:阿里云大数据产品及研发团队专家 产品 MaxCompute 官网 https://www.aliyun.com/product/odps&nbsp;
目录
相关文章
|
1天前
|
算法 Serverless 数据处理
从集思录可转债数据探秘:Python与C++实现的移动平均算法应用
本文探讨了如何利用移动平均算法分析集思录提供的可转债数据,帮助投资者把握价格趋势。通过Python和C++两种编程语言实现简单移动平均(SMA),展示了数据处理的具体方法。Python代码借助`pandas`库轻松计算5日SMA,而C++代码则通过高效的数据处理展示了SMA的计算过程。集思录平台提供了详尽且及时的可转债数据,助力投资者结合算法与社区讨论,做出更明智的投资决策。掌握这些工具和技术,有助于在复杂多变的金融市场中挖掘更多价值。
22 12
|
1月前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
42 5
|
4月前
|
C语言 C++
实现两个变量值的互换[C语言和C++的区别]
实现两个变量值的互换[C语言和C++的区别]
52 0
|
4月前
|
存储 编译器 程序员
C++类型参数化
【10月更文挑战第1天】在 C++ 中,模板是实现类型参数化的主要工具,用于编写能处理多种数据类型的代码。模板分为函数模板和类模板。函数模板以 `template` 关键字定义,允许使用任意类型参数 `T`,并在调用时自动推导具体类型。类模板则定义泛型类,如动态数组,可在实例化时指定具体类型。模板还支持特化,为特定类型提供定制实现。模板在编译时实例化,需放置在头文件中以确保编译器可见。
52 11
|
5月前
|
C++
继续更新完善:C++ 结构体代码转MASM32代码
继续更新完善:C++ 结构体代码转MASM32代码
|
5月前
|
存储 算法 C++
【C++核心】结构体、共用体详解
这篇文章详细讲解了C++中结构体和共用体的概念、定义、使用场景和案例,包括结构体的创建、数组、指针、嵌套、函数参数传递,以及共用体的特点和应用实例。
68 4
|
5月前
|
JavaScript 前端开发 Java
通过Gtest访问C++静态、私有、保护变量和方法
通过Gtest访问C++静态、私有、保护变量和方法
150 0
|
5月前
|
安全 程序员 C语言
C++(四)类型强转
本文详细介绍了C++中的四种类型强制转换:`static_cast`、`reinterpret_cast`、`const_cast`和`dynamic_cast`。每种转换都有其特定用途和适用场景,如`static_cast`用于相关类型间的显式转换,`reinterpret_cast`用于低层内存布局操作,`const_cast`用于添加或移除`const`限定符,而`dynamic_cast`则用于运行时的类型检查和转换。通过具体示例展示了如何正确使用这四种转换操作符,帮助开发者更好地理解和掌握C++中的类型转换机制。
|
6月前
|
C++
使用 QML 类型系统注册 C++ 类型
使用 QML 类型系统注册 C++ 类型
165 0
|
6月前
|
存储 安全 C++
C++:指针引用普通变量适用场景
指针和引用都是C++提供的强大工具,它们在不同的场景下发挥着不可或缺的作用。了解两者的特点及适用场景,可以帮助开发者编写出更加高效、可读性更强的代码。在实际开发中,合理选择使用指针或引用是提高编程技巧的关键。
55 1