优秀的编程知识分享平台

网站首页 > 技术文章 正文

C++基础（c基础语法）

nanyue 2024-08-16 00:41:54 技术文章 6 ℃

使用c++语言编写一个求圆的面积的程序：

#include"iostream"//包含C++的头文件

using namespace std;//使用std标准命名空间(在这个命名空间中定义了很多标准定义)

void main01()
{
	//printf("helloworld\n");

	//cout 标准输出
	//endl 回车换行
	cout << "hello world" << endl;

	system("pause");
}

//求圆的面积
//用面向过程的方法求圆形面积
int main02()
{ 
	double r = 0;
	double s = 0;
	cout << "请输入原型半径:";
	cin >> r;//跟scanf 功能类似
	cout << "r的值是：" << r << endl;
	s = 3.14 * r * r;
	cout << "圆形面积是s:" << s << endl;

	system("pause");
	return 0;
}

//--------------------------------------------
//面向对象求解圆的面积   定义了一个圆的数据类型
struct circle
{
	double m_s;//圆的面积
	double m_r;//圆的半径
};

//类是一个抽象的概念，不会分配内存
//用数据类型定义变量的时候，才会分配内存
class Mycircle
{
public:
	double m_s;//圆的面积  
	double m_r;//圆的半径
public:
	void setR(double r)//成员函数
	{
		m_r = r;
	}
	double getR()
	{
		return m_r;
	}
	double getS()
	{
		m_s = 3.14 * m_r * m_r;
		return m_s;
	}
};

//面向过程加工的是一个个的函数
//面向对象加工的是一个个的类
int main0103()
{
	Mycircle c1, c2, c3;//用类  定义变量  对象c1、c2
	double r1, r2, r3;
	
	cout << "请输入c1圆的半径:";
	cin >> r1;
	//给c1圆的属性赋值
	c1.setR(r1);
	cout << "c1圆形的面积是：" << c1.getS() << endl;

	cout << "请输入c2圆的半径:";
	cin >> r2;
	//给c2圆的属性赋值
	c2.setR(r2);
	cout << "c2圆形的面积是：" << c2.getS() << endl;

	cout << "请输入c3圆的半径:";
	cin >> r3;
	//给c3圆的属性赋值
	c3.setR(r3);
	cout << "c3圆形的面积是：" << c3.getS() << endl;

	system("pause");
	return 0;
}

命名空间的概念：

#include"iostream"
using namespace std;

//1.文件中 iosteam 没有引入标准std ，需手动写
//2.若不写 using namespace std 需显示的 引入std。  std::cout << "namespace test" << std::endl;

void main0201(void)
{
	std::cout << "namespace test" << std::endl;

	system("pause");
}

//3.定义命名空间
namespace namespaceA
{
	int a = 0;
}

namespace namespaceB
{
	int a = 10;
	namespace namespaceC
	{
		struct Teacher
		{
			char name[32];
			int age;
		};
	}
}
//4.使用命名空间
void main0202(void)
{
	using namespace namespaceA;
	using namespace namespaceB;
	cout << namespaceA::a << endl;
	//cout << namespaceB::a << endl;

	//路径写全
	//namespaceB::namespaceC::Teacher t1;
	//t1.age = 33;
	//cout << t1.age << endl;

	using namespaceB::namespaceC::Teacher;
	Teacher t2;
	t2.age = 31;
	cout << t2.age << endl;

	system("pause");
}

布尔类型的数据

#include"iostream"
using namespace std;

void main0401()
{
	bool b1 = true;//1字节大小

	bool b2, b3, b4;//多个bool变量定义在一起可能会占1个bit
	cout << "sizeof(bool):" << sizeof(bool) << endl;

	//bool 变量 1或0
	b1 = 10;
	cout << "b1:" << b1 << endl;

	b1 = 0;
	cout << "b1:" << b1 << endl;
	system("pause");
}

三目运算符与c语言中不同：

#include"iostream"
using namespace std;

//	c语言中返回的是变量的值
//	c++中表达式返回的是变量的本身

//实现原理：	即等号左侧是一个内存的首地址  即指针
//在c语言中如何实现跟c++中同样的效果呢，*(a < b ? &a : &b) = 30
void main05()
{
	int a = 10;
	int b = 20;

	//判断a是否<b  若为真将30赋值给a  反之赋值b为30
	(a < b ? a : b) = 30;
	cout << a << endl;
	system("pause");
}

const的使用方式

#include"iostream"
using namespace std;


struct Teacher
{
	char name[64];
	int age;
};

//这里const修饰的是指针指向的内存空间无法修改
int printTeacher01 (const Teacher*pt)
{
	//pt->age = 10;//err
	return 0;
}

//这里的const修饰的是指针变量本身  指针的指向不能修改
int printTeacher02( Teacher* const pt)
{
	pt->age = 10;//true
	//tp = NULL;//err
	return 0;
}

//两者都不能被修改
int printTeacher03(const Teacher* const pt)
{
	//pt->age = 10;//err
	//tp = NULL;//err
	cout << pt->age << endl;
	return 0;
}

void main0601()
{
	//const int a = 1;
	//int const b = 2;//两种修饰效果一致

	//const int* c;//const修饰的指针所指向的内存空间 不可修改
	//int* const d = &a;//修饰的是指针变量本身的指向不能被修改
	//const int* const e;//指向的内存空间与指向都不能修改

	Teacher t1;
	t1.age = 31;
	printTeacher03(&t1);

	system("pause");
}

//c++编译器中const修饰的常量不能通过指针来修改  是真正的不可修改的
void main0602()
{
	const int a = 10;
	int* p = NULL;
	p = (int*)&a;//会为p重新分配一个内存空间  而不是指向a
	*p = 20;
	printf("a=%d\n", a);
	printf("*p=%d\n", *p);
	system("pause");
}

//	const与#define的相同之处
//	在编译预处理阶段 处理 
#define d 20
void main0603()
{
	int a = 10;
	int b = 20;
	//int arr[a + b];//err数组下标不可以用变量  Linux内核允许这种方式
	//c和c++中不支持

	const int c = 10;
	//const int d = 20;
	int arr[c + d];//true
	system("pause");
}

//----------------------------------------------------------
//	const定义的变量，由编译器处理，提供类型检查和作用域检查
void func1()
{
#define a 10
	const int b = 20;
//#undef				//确保这个宏只在当前函数作用域中生效
	//#undef a 只卸载a这个宏		#undef 卸载所有的宏
}

//在func1中的宏定义也能在func2中生效
//func1中的const常量不能再func2中使用
void func2()
{
	printf("a=%d\n", a);
	//printf("b=%d\n", b);//err
}

int main0604()
{
	func1();
	func2();
	return 0;
}

引用的概念：

引用所占用的空间大小与指针相同。

引用在C++中的内部实现其实是一个常量指针。

//c++中引用方式修改变量的值
void func (int& a)
{
 a=5;
}
//c语言中指针方式修改变量的值
void func (int* a)
{
* a=5;
}
#include"iostream"
using namespace std;


//1.引用概念 
void main0701()
{
	int a = 10;

	//引用的语法：type& name = var;  

	int& b = a;  //给a起别名 为b
	b = 100;//相当于给a改为100

	printf("b:%d\n", b);
	printf("a:%d\n", a);

	a = 10;
	printf("a:%d\n", a);
	printf("b:%d\n", b);
}

//基础类型的引用
void myswap01(int a, int b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}
void myswap02(int* a, int* b)
{
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}

//引用方式   引用做函数参数时不需要进行初始化
void myswap03(int& a, int& b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}
void main0702()
{
	int x = 10;
	int y = 20;
	myswap01(x, y);
	printf("x:%d,y:%d\n", x, y);

	myswap02(&x, &y);
	printf("x:%d,y:%d\n", x, y);

	myswap03(x, y);//引用方式
	printf("x:%d,y:%d\n", x, y);

	system("pause");
}

//-----------------------------
//复杂数据类型
struct Teacher
{
	char name[64];
	int age;
};

void printT(Teacher* pt)
{
	cout << pt->age << endl;
}

//pt是t1的别名  相当于修改了t1
void printT2(Teacher& pt)
{
	pt.age = 33;
}

void printT3(Teacher pt)
{
	cout << pt.age << endl;
	pt.age = 34;//err修改的值不能反回到主函数
}
void main0703()
{
	Teacher t1;
	t1.age = 30;
	printT(&t1);
	printT2(t1); //pt是t1的别名
	printT3(t1);//pt 是形参，t1拷贝一份数据给pt
	cout << t1.age << endl;
	system("pause");
}

引用作为函数的返回值

#include"iostream"
using namespace std;


int getA1()
{
	int a;
	a = 10;
	return a;
}

//返回a的本身  a的一个副本
int& getA2()
{
	int a;
	a = 10;
	return a;
}

int* getA3()
{
	int a;
	a = 10;
	return &a;
}

//若返回栈变量  不能成为其他引用的初始值
void main0901()
{
	int a1 = 0;
	int a2 = 0;
	a1 = getA1();
	a2 = getA2();
	int &a3 = getA2();//可能返回乱码  不建议这样使用

	printf("a1:%d,a2:%d,a3:%d\n", a1, a2, a3);
	system("pause");
}


//----------------------------
//变量是static 或者是全局变量

int j1()
{
	static int a = 10;
	a++;
	return a;
}

int& j2()
{
	static int a = 10;
	a++;
	return a;
}

void main0902()
{
	int a1 = 10;
	int a2 = 20;
	 
	a1 = j1();
	a2 = j2();
	int& a3 = j2();
	printf("a1=%d\n", a1);
	printf("a2=%d\n", a2);
	printf("a3=%d\n", a3);
	system("pause");
}

//-----------------------------------------
//函数当左值
//返回变量的值
int g1()
{
	static int a = 10;
	a++;
	return a;
}
//返回变量本身
int& g2()
{
	static int a = 10;
	a++;
	printf("a:%d\n", a);
	return a;
}

void main0903(void)
{
	//g1() = 100;  err
	//11 = 100   g1()=11

	g2() = 100;//函数返回值是引用并且当左值
	g2();
	
	int c1 = g1();//函数返回值是引用并且当右值
	int c2 = g2();
	system("pause");

}

指针的引用

#include"iostream"
using namespace std;

struct Teacher
{
	char name[64];
	int age;
};

//在被调函数获取资源
int getTeacher(Teacher** p)
{
	Teacher* temp = NULL;
	if (p==NULL)
	{
		return -1;
	}
	temp = (Teacher*)malloc(sizeof(Teacher));
	if (temp==NULL)
	{
		return -2;
	}
	temp->age = 33;
	//p是实参地址  *实参地址 间接修改实参的值
	*p = temp;
}


//	这里的	Teacher*	跟main函数中pt1的类型相同
int getTeacher2(Teacher*& myp)
{
	//这里给myp赋值相当于给main函数中pt1赋值
	myp = (Teacher*)malloc(sizeof(Teacher));
	if (myp==NULL)
	{
		return -1;
	}
	myp->age = 36;

}

void FreeTeacher(Teacher* pt1)
{
	if (pt1==NULL)
	{
		return;
	}
	free(pt1);
}

void main1001()
{
	Teacher* pt1;
	//	1.用c语言中的2级指针方式调用
	getTeacher(&pt1);
	cout << "pt1.age=" << pt1->age << endl;
	FreeTeacher(pt1);

	//	2.用C++中指针的引用方式调用
	getTeacher2(pt1);
	cout << "pt1.age=" << pt1->age << endl;
	FreeTeacher(pt1);

	system("pause");
}

Tags：

猜你喜欢

最近发表
标签列表