从C过度到C++

最新推荐文章于 2024-07-13 17:33:57 发布
最新推荐文章于 2024-07-13 17:33:57 发布
阅读量248 收藏
点赞数
分类专栏： C++ 文章标签： c++ 编程语言 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pintitus/article/details/105162670
版权

从C过度到C++

语法的升级

引用：		void swp(int &a , int &b);
默认参数：	void debug(const char *ptr = "------");
函数重载：	int cmp(itn data1 , int data2);
			int cmp(const char *str1 ,const char *str2);
堆内存： malloc() , free() -> new , delete
引用
#include <stdio.h>
int main(int argc, const char *argv[])
{
	int a = 100;
	int &b = a;//引用的用法，最终打印出来无论是值还是地址都一样。
	printf("a = %d\n" , a);
	printf("b = %d\n" , b);
	printf("add a = %p\n" , &a);
	printf("add b = %p\n" , &b);
	return 0;
}
//打印输出
a = 100
b = 100
add a = 0xbffc9bd8
add b = 0xbffc9bd8
默认参数
void debug(const char *ptr = "---------------"){
	printf("%s\n" , ptr);
}
int main(int argc, const char *argv[])
{
	debug();
	debug("hello");
	return 0;
}
//打印
---------------
hello
重载

可以使用同样的函数名，但是要求参数一定不能一样

#include"stdio.h"
#include"string.h"

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

int cmp(const char *str1 , const char *str2){
	return strcmp(str1 , str2);
}
int main(int argc, const char *argv[])
{
	printf("%d\n" , cmp(1,2));
	printf("%d\n" , cmp("aaaaa","bbbb"));
	return 0;
}
linux@linux:~/c++$ ./a.out 
-1
-1
malloc
#include"stdio.h"
#include <malloc.h>
#include <string.h>
int main(int argc, const char *argv[])
{
    //申请一个堆空间
	int *intp = new int;
	*intp = 100;
	printf("int*p = %d\n" , *intp);
	delete intp;
    //申请多个堆空间
	char *p = new char[10];
	strcpy(p , "hello");
	printf("p: %s\n" , p);
	delete [] p;
	return 0;
}
linux@linux:~/c++$ ./a.out 
int*p = 100
p: hello

类与对象

​ 在C语言中，我们想要写得不错一些，体现面向对象以及封装结构体更加高级的感觉。将同一类需要的数据封装在一个结构体内。但是这仍旧在顶级工程师眼里不算厉害。

C的面向对象写法（中阶）
//arr.h
#ifndef __ARR__
#define __ARR__

    typedef struct arr{
        int data[100];
        int tail;
    }ARR;
    extern void init(ARR *arr);
    extern void show(ARR *arr);
    extern void addtail(ARR *arr , int data);
#endif
//arr.c
#include<stdio.h>
#include "arr.h"
void init(ARR *arr){
	arr->tail = 0;
}
void show(ARR *arr){
	int i = 0 ;
	for(;i < arr->tail ; i++)
		printf("%d , " ,arr->data[i] );
	printf("\n");
}
void addtail(ARR *arr , int data){
	arr->data[arr->tail++] = data;
}
C的升级写法（高阶）

​ 对象与方法需要有绑定关系。拿到对象就需要操作它的方法。

​ 将对象中的属性与方法进行绑定。对象的方法写入static进行修饰，就可以达到无法被外部随意调动的含义。将方法以函数指针的形式写入结构体中，当创建一个对象以后，不代表我们的对象的函数指针就绑定了相对应的函数，还需要在具体地指定函数指针指向某个函数

#include<stdio.h>
#include "arr.h"
static void show(ARR *arr){
	int i = 0 ;
	for(;i < arr->tail ; i++)
		printf("%d , " ,arr->data[i] );
	printf("\n");
}
static void addtail(ARR *arr , int data){
	arr->data[arr->tail++] = data;
}
void init(ARR *arr){
	arr->tail = 0;
	arr->addtail = addtail;		//对函数指针进行具体函数的绑定，指向目标函数
	arr->show = show;
}
//arr.h
#ifndef __ARR__
#define __ARR__
typedef struct arr{
	int data[100];
	int tail;
	void (*show)(struct arr *arr);
	void (*addtail)(struct arr *arr , int data);
}ARR;
void init(struct arr *arr);
#endif


//main.c
#include "arr.h"
int main(int argc, const char *argv[])
{
	ARR arr;
	int n =10;
	init(&arr);
	while(n--)
		arr.addtail(&arr , n);
	arr.show(&arr);
	return 0;
}
C语言中的弊端：

​ 但是如果我们在main.c中的show函数前面修改arr.tail变量的话，假如使arr.tail = 0;那么，我们最后所展示的arr会达不到我们想要的效果。也就是说这种封装方法容易出现被在某一个地方修改变量的值有可能出现重大错误，而找错误极其不容易。

​ 1.加入修改对象成员变量的语句容易会整个修改程序执行的结果。

​ 2.我已经找到了成员结构，确还要进行传入我本人的结构体，这不是很荒唐的事情吗？

C++引入类

默认private -> 太安全
//class.cpp
#include "stdio.h"
class A{
	int a;
};
int main(int argc, const char *argv[]){
	A x;
	x.a = 100;
	return 0;
}
//执行结果
linux@linux:~/c++/class$ g++ class.cpp 
class.cpp: In function ‘int main(int, const char**)’:
class.cpp:4:6: error: ‘int A::a’ is private
  int a;
      ^
class.cpp:10:4: error: within this context
  x.a = 100;
    ^

​ 看似我们的C++的程序的类类似于C的结构体，但是有很大不同，它防止你对成员直接进行修改。

class A{
	int a;
	void show(){
		printf("----------\n");
	}
};
int main(int argc, const char *argv[])
{
	A x;
	x.show();
	return 0;
}

​ 那么我们想要调用结构体中的方法，也是会出错误的，它太安全了，以至于没有什么用

无法调用的解决方法：
关键字

​ 为了达到我们想要的效果：变量不可以随意修改，函数可以调用从而解决我们在C语言下的困惑，我们可以给类使用关键字

​ 我们如果想要修改变量的值，需要在public修饰下进行封装接口才能修改我们的私有变量。在C++中我们的变量是比较另类的。你在类A的外部没有声明变量他也可以调用到a，这就体现了我的类别是可以调用自己类别的，只要你声明是我本身的类A就可以了，“A::”。

#include "stdio.h"
class A{
	private:
		int a;
	public:
		void show(){
			printf("----------\n");
		}
		void setdata(int data){
			a= data;
		}
		int getdata(void);
};
int A::getdata(void){
	return a;
}
int main(int argc, const char *argv[])
{
	A x;
	x.show();

	x.setdata(100);
	printf("%d\n" , x.getdata());
	
	return 0;
}
//执行结果
linux@linux:~/c++/class$ ./a.out 
----------
100
构造方法
无参构造函数

​ 在类中可以定义同名方法，也就是你构造类的对象以后会直接执行的方法。注意：它必须是public下的，否则会报错。

​ 用于初始化行为，给我的类的成员进行初始化

//执行结果
linux@linux:~/c++/class$ ./a.out 
A的同名方法被执行----------
100
//class.cpp
#include "stdio.h"
class A{
	private:
		int a;
	public:
		A(){							 //构造对象以后会默认执行的函数
			printf("A的同名方法被执行");	//
         	 a = 0;						  //完成初始化行为
		}								//
		void show(){
			printf("----------\n");
		}
		void setdata(int data){
			a= data;
		}
		int getdata(void);
};
int A::getdata(void){
	return a;
}
int main(int argc, const char *argv[])
{
	A x;
	x.show();

	x.setdata(100);
	printf("%d\n" , x.getdata());
	
	return 0;
}
有参构造函数
//执行结果
linux@linux:~/c++/class$ ./a.out 
----------
0
100
//class.cpp
#include "stdio.h"
class A{
	private:
		int a;
	public:
		A(){
			printf("A的同名方法被执行");
			a = 0;
		}
		A(int data){			//有参构造函数
			a= data;			//
		}						//
		void show(){
			printf("----------\n");
		}
		void setdata(int data){
			a= data;
		}
		int getdata(void);
};
int A::getdata(void){
	return a;
}
int main(int argc, const char *argv[])
{
	A x(0);
	x.show();

	printf("%d\n" , x.getdata());
	x.setdata(100);
	printf("%d\n" , x.getdata());
	return 0;
}
析构函数

该函数会在对象x被销毁的时候执行。，在同名方法前面加一个’~’。

不如在创建一个malloc申请资源以后，方便释放掉资源。

//执行结果
linux@linux:~/c++/class$ ./a.out 
----------
0
100
//
#include "stdio.h"

class A{

	private:
		int a;
	public:
		A(){
			printf("A的同名方法被执行");
			a = 0;
		}
		A(int data){
			a= data;
		}
		~A(){									//析构函数
			printf("PROGRAM OVER!BYE BYE!\n");	   //
		}										//
		void show(){
			printf("----------\n");
		}
		void setdata(int data){
			a= data;
		}
		int getdata(void);
};
int A::getdata(void){
	return a;
}
int main(int argc, const char *argv[])
{
	A x(0);
	x.show();

	printf("%d\n" , x.getdata());
	x.setdata(100);
	printf("%d\n" , x.getdata());
	
	return 0;
}

C++对C的诠释

​ 实现：1.尾部添加成员 2.打印数组成员

​ 其中我们构建对象，一个排列数组和指向尾巴的参数。由于类的私有成员不能随意修改因此提供接口在数组尾部添加数组成员以及打印成员。

this指针：

​ this指针就是说，如果在一个函数参数的位置有个变量data，我们类的内部有个与data相同名字的变量的时候，我们this用来区分这两个变量的。this声明是类中的私有属性。

//arr.h
#ifndef _ARR_
#define _ARR_

class ARR{
	public:
		ARR():tail(0){ 				//初始化表初始化方法	   >>方法2
//			tail = 0;									>>方法1
		}
		void addtail(int data);		//类似于C的函数指针
		void show(void);			
	private:
		int data[100];
		int tail;
};
#endif
//arr.c
#include<stdio.h>
#include "arr.h"

void ARR::show(void){				//是ARR结构体的共有方法
	int i = 0 ;
	for(;i < tail ; i++)
		printf("%d , " ,data[i] );
	printf("\n");

}
void ARR::addtail(int data){
	this->data[tail++] = data; 	//当私有变量与参数崇明，使用this指针
}
//main.c
#include<stdio.h>
#include "arr.h"
int main(int argc, const char *argv[])
{
	ARR arr;
	arr.addtail(10);
	arr.addtail(12);
	arr.addtail(14);
	arr.addtail(16);
	arr.addtail(18);
	arr.show();
	return 0;
}

​ 这样的写法显得主方法结构简洁，逻辑清晰，写出了我们心目中想要的压子。

多种构建对象方法

​ 这里有四种构建对象的方法，其中我们执行结果发现只执行了3次A方法，而执行了4次析构函数。

​ 其中第一种一定调用了无参数构造函数，第二次也一定调用了有参构造函数，第三次系统默认的调用有参构造函数，第四次其实是复制了一份快捷方式，他们的资源指向同一个地方。这种方式构建是很危险的。

第四种方法造成的错误
#include <stdio.h>

class A{
	public:
		A(){
			printf("-------1");
		}
		A(int data){
			printf("A data:%d\n",data);
		}
		~A(){
			printf("A-------------\n");
		}
};
int main(int argc, const char *argv[])
{	
	//called when new object is created
	A *p = new A(100);
	A x;
	A m(100);
	A y = 10;
	A z = y;
	return 0;
}

​ 如果我们的构造函数是在堆空间创建一个资源，而最后y和z同时分配到一块空间。其实相当于：创建y以后我们又创建了y的快捷方式，最后我们执行结果以后会出现double free的错误操作，我们在free y的过程中，z的资源已经没有了，那么我们又对该空间进行释放。

//执行结果
A()
~A()
~A()
*** Error in `./a.out': double free or corruption (fasttop): 0x093bf008 ***
Aborted (core dumped)
//执行程序
#include <stdio.h>
class A{
	public:
	A(){
		printf("A()\n");
		p = new char [10];
	}
	~A(){
		printf("~A()\n");
		delete [] p; 
	}
private:
	char *p;
};
int main(int argc, const char *argv[])
{
	A x;
	A y = x;
	return 0;
}
深拷贝构造函数的实现：

​ 为了解决上述第四种方法造成的严重问题，对于拷贝拷贝到了同一片内存空间。针对这个问题，需要实现深拷贝，而不再是仅仅创建了一个快捷方式。

​ 这种方法不能解决y = x这种拷贝方式，需要C++重载机制，在后面会讲到。

//执行结果
linux@linux:~/c++/class/3$ ./a.out 
A()				//申请堆空间资源
A(const A &x)	 //深拷贝，拷贝时没有在同一块内存中
~A()
~A()
//2_class.pp
#include <stdio.h>
#include <string.h>

class A{
	public:
	A(){
		printf("A()\n");
		p = new char [10];
		strcpy(p , "hello");
	}
	A(const A &x){//针对拷贝,不会指向原来地址,实现深拷贝
		printf("A(const A &x)\n");
		p = new char [10];
		strcpy(p , x.p);
	}
	~A(){
		printf("~A()\n");
		delete [] p; 
	}
private:
	char *p;
};
int main(int argc, const char *argv[])
{
	A x;
	A y = x;
	return 0;
}

常成员

​ const不能进行数据的操作。

​ static属于类而不属于某个对象。

const：

​ const数据成员只在某个对象生存期内是常量，而对于类而言是个可变的。（static 例外）

​ const 修饰变量 ------------ 不能修改变量，只能在初始化的时候进行设置

​ const 函数 ------------ 函数内部不能进行变量修改

//执行结果
A()
b = 1000
a = 10
A()
b = 1000
a = 100
A()
b = 1000
a = 50
~A()
~A()
~A()
//const.cpp
#include <stdio.h>
class A{
	public:
		A(int a=50 , int data = 1000):b(data){
			this->a = a;
			printf("A()\n");
		}
		~A(){
			printf("~A()\n");
		}
		void show() const{ 	//常函数
			printf("b = %d\n" , b);
			printf("a = %d\n" , a);
		}
	private:
		int a;
		const int b; //常成员只能在初始化中定义
};

int main(int argc, const char *argv[])
{
	A x(10);
	x.show();

	A y(100);
	y.show();

	A z;
	z.show();
	return 0;
}

static：

​ static函数：基于类而不基于对象

​ static变量：首先必须要在类外声明变量，不基于对象的变量

//执行结果
linux@linux:~/c++/class/4_const$ ./a.out 
xxxxxxxxx
xxxxxxxxx
//static.cpp
#include <stdio.h>
class A{
	public:
		static void func(){
			printf("xxxxxxxxx\n");
		}
	static int data;
};
int A::data = 10;				//很重要
int main(int argc, const char *argv[])
{
	A a;
	a.func();
	A::func();  			//通过类调用函数
    
    A x;
    x.data = 100;
    A::data = 1000;			//通过类调用数据
	return 0;
}

友元 friend

​ 使用friend关键字。

友元函数

​ 在一个外部函数你想使用某个类的私有变量就可以用到friend关键字。作为我这个类的朋友，就可以使用我的private变量了。

//执行结果
linux@linux:~/c++/class/5_friend$ ./a.out 
10 , 12 , 14 , 16 , 18 , 
18 , 16 , 14 , 12 , 10 , 
//程序段
#ifndef _ARR_
#define _ARR_
class ARR{
	public:
		ARR():tail(0){
		}
		void addtail(int data);
		void show(void);
		friend void rev(ARR &arr);			//自己的函数操作自己的函数
	private:
		int data[100];
		int tail;
};
#endif

linux@linux:~/c++/class/5_friend$ cat main.cpp 
#include<stdio.h>
#include "arr.h"
void rev(ARR &arr){					//需要使用ARR类的私有变量
	int i=0 ;
	for(;i<arr.tail/2 ; i++){
		int tem = arr.data[i];
		arr.data[i] = arr.data[arr.tail-i-1];
		arr.data[arr.tail-i-1] = tem;
	}
}

int main(int argc, const char *argv[])
{
	ARR arr;

	arr.addtail(10);
	arr.addtail(12);
	arr.addtail(14);
	arr.addtail(16);
	arr.addtail(18);
	
	arr.show();
	rev(arr);
	arr.show();
	return 0;
}

友元类

​ 现在我想要以一个例子来实现一个类B去调用另一个类A的私有变量。如果常规来想是不可能的，你甚至都不能在主方法中去打印A类的值。

​ 但是，如果我们在A中添加B为朋友的话，那么B就可以去调用A的私有变量了。

//执行结果
linux@linux:~/c++/class/5_friend$ ./a.out 
100					//class B调用到了class A的私有变量
//程序段
#include<stdio.h>

class A{
	public:
		A(){
			x = 100;
		}
		friend class B;
	private:
		int x;
};

class B{
	public:
		void printfA(A &x);
};

void B::printfA(A &x){
	printf("%d\n" , x.x);
}

int main(int argc, const char *argv[])
{
	A a;
	//printf("%d\n" , a.x);
	B b;
	b.printfA(a);
	return 0;
}

友元成员函数

对于上述事例而言，我的B其实只想调用A的一个x的私有变量，并不带表全部的东西都可以随意使用，这样会容易造成问题。因此我们可以只将B的printfA函数进行声明为朋友。

class A{
	public:
		A(){
			x = 100;
		}
		friend void B::printfA(A &x);
	private:
		int x;
};
OOP 面向对象编程：由 C语言到 C++
编程与实战的博客
12-19 1080
链接：https://www.cnblogs.com/whale90830/p/10488595.html由C到C++OOP第一课C语言的局限C++的特点C++的程序特征C++程序的结构...
c 到C++ 过度
qq_40535507的博客
07-19 195
cdaoc++guodu
c过渡到c++
cw312644167的博客
12-20 603
1.为什么要学习c++？ c++能够提高程序的运行效率 通过这张能力雷达表可以看出c++的个方面能力都是比较强的。在生产力上目前虽然比不上java，但它的的效率和灵活度上是Java无可比的。 c++不仅仅是一门单纯的编程语言，它可以看做是一个语言的联盟，各种语言的优点都被c++所吸收。因为c++壤扩的范围太大，所以学习起来会有一定难度。 c++当中
第一节课：C过度到C++--之一
艺术人生的专栏
12-21 545
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
C过度到C++
Silence_Fall的博客
07-19 269
简单来说C++是C语言的超集，C的语法C++都支持。但是C++与C有还是有很大差别的。以下是我学习C++过程中的一些总结： 1.命名空间 命名空间将全局作用域分成不同的部分 不同命名空间中的标识符可以同名而不会发生冲突 命名空间可以相互嵌套 全局作用域也叫默认命名空间 2.实用性 在C++中所有的变量都可以在需要使用时再定义。 3.register的变化 C中无法对registe...
高效C++：从C到C++
07-07
### 高效C++：从C到C++ #### 第一章：从C转向C++ **条款1：尽量用const和inline而不用#define** - **背景**：在C语言中，`#define`宏定义被广泛用于常量的定义。然而，在C++中，我们有更好的替代方案——`const`...
从c到c++的过度
02-17
【从C到C++的过渡】是一个关于编程语言学习的主题，主要探讨了C语言与C++语言的区别以及如何平滑地从C过渡到C++。本文将深入解析这两个语言的关键差异，尤其是涉及到函数重载、有默认参数的函数以及变量的引用等C++...
华为技术有限公司C++语言编程规范,华为技术有限公司c语言编程规范.pdf,C,C++
09-10
《华为技术有限公司C++语言编程规范》是一份深入细致的编程指南，旨在为开发者提供一套在C++编程中应遵循的最佳实践。这份规范不仅适用于华为公司内部开发，也对外界开发者具有很高的参考价值，帮助他们提升代码质量...
从C语言过渡到C++
qq_42731435的博客
11-05 1434
头文件与命名空间 输入输出 bool 类型 string 类型 const constexpr 变量定义位置 动态内存管理 类型转换 默认参数与函数重载 带参宏 内联函数 指针与引用 空指针 智能指针
C到C++完美过度（一）
chlik的博客
12-20 1813
6、Overloaded重载 5、库 4、new delete（c：mylloc\free） 3、输出 2、BOOL C++语义 推荐参考书籍 stdaf.h
C过渡C++基础（较详细）
iuu77的博客
11-05 944
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 C语言想过渡C++，不想重新学习但又不想囫囵吞枣。这是本人的学习笔记 提示：以下是本篇文章正文内容，下面案例可供参考 一、C语言和C++的区别 C++语言是C语言的扩展和增强，由原来的面向过程编程转变成面向对象、通用算法（泛型编程） 由于C++是C语言的扩展，所以C语言程序也是C++程序，原有的.c 程序可
c到c++的过渡
qq_42664422的博客
02-09 238
1.c到c++的过度 1 2.类和对象 2 3.继承与派生 1 4.运算符重载 1 5.多态 1 6.函数模板与类模板 1 7.异常与文件 1 c++的基本知识 ------------------------------------ 8.STL 标准模板库 2 9.设计模式 2 10.QT 2+ mysql 1 1. 汇编 低级语言 可以直接操作硬件 MOV 移植...
从C到C#
GingSam的专栏
12-24 752
两年前接触了C，随后学了C#，可是没想到，两年后又重新学C。从C到C#，这条路有多长啊？
C++初阶：从C语言过渡到C++
最新发布
LWX10086的博客
07-13 836
当我们有一定的C语言基础，再去学习另一（C++）相对来说便会容易很多，而要学习一门新的语言，首先我们就要学习他的语法，而且每一门语言都有其独特的优势，我们的·C++祖师爷也正因为C语言的一些不便之处将其以更方便的形式在C++中所实现，下面让我带大家一起从C语言过度到C++，走进C++的世界。
一文带你从C快速过渡到C++
Dakhin的博客
08-15 6517
从C快速过度到C++！如果你学习过C语言，想要快速学会C++，不想重头开始看视频，那么该篇文章应该能帮助到您。
（超详细）如何由C过度到C++
m0_59086897的博客
02-04 1563
目录 一、C和C++的区别 二、由C快速过度到C++ 1、C与C++的框架不同点（不同处有红色标记） 2、C与C++不同的总结 3、初步掌握 三、C++的函数库(使你变强) 一、C和C++的区别 1、C语言可以在C++编译器上运行（C++包涵C） 2、C++与C相比有函数库（STL、BOOST等等） 3、C++是面向对象的编程语言（有class类及特性） 二、由C快速过度到C++ 1、C与C++的框架不同点（不同处有红色标记） 由C对比C++ ①C版框架： #include
如何从C快速过渡到C++
热门推荐
帅比王的博客
07-03 2万+
1.C和C++的区别：C语言可以在C++编译器上完美运行，即C属于C++C++比C多出来一些函数库C++是面向对象编程（即有class以及相关工具）2.如何从C过渡到C++2.1 代码实例：（C语言版）uva11000.#include&lt;stdio.h&gt; int main() { long long m = 0, fm = 1, sum = 1; int n,i; while(s...
C++编程实践：从C到C++的转型指南
在C++编程中，从C语言过渡到C++会遇到一些挑战，因为C++提供了更丰富的特性和概念。C++不仅保留了C语言的基础，如宏、指针、结构、数组和函数，还引入了面向对象的特性，如类、继承、多态以及模板等。然而，一些C...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值