02-C++ 与C的差异

最新推荐文章于 2024-06-15 10:30:23 发布
最新推荐文章于 2024-06-15 10:30:23 发布
阅读量1.3k 收藏 19
点赞数 13
分类专栏： C/C++ 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhb_feng/article/details/135098777
版权

c++ 与c的差异

1. QT中文乱码问题

工具 -- 选项 -- 行为 -- 文件编码改为system

在这里插入图片描述

注意：

  • 修改后新项目中文才不会乱码，如果是原有项目需重建 。

2. 输出

语法：

cout << 输出内容1 << 输出内容2 << ... << endl;

注意:

  • 输出的内容中 endl 表示为换行

  • c语言的输出是 stdio.h 中提供了 printf 函数进行标准输出

    • printf("输出的格式"，值1，值2，值3，...)；

  • c++的输出是 iostream 中提供的 cout 变量进行标准输出

    • cout << 值1 << 值2 << 值3...endl;

示例：

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    int a = 666;
    cout << "a的值是：" << a << endl;
    return 0;
}

//a=10

3. 输入

语法：

cin >> 变量名1 >> 变量名2 >> ...

示例：

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    cout << "请输入一句话：" << endl;
    char str[30];
//    cin >> str;
//    cout << "str= " << str << endl;
    cin.getline(str, sizeof(str));
    cout << "str= " << str << endl;
    return 0;
}

注意：

  • 直接使用 cin ，不能有空格、换行。

  • 要是用 cin.getline(str,sizeof(str));

  • c语言的输入stdio.h 提供了

    • scanf("格式"，存储输入的数据的地址);
int num = 10;
scanf("%d", &num);

  • c++的输入 iostream，提供了 cin 。

在这里插入图片描述
在这里插入图片描述

4. 作用域运算符

通常情况下，如果有两个同名变量，一个是全局变量，另一个是局部变量，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。

符号：

::

作用：作用域运算符可以用来解决局部变量与全局变量的重名问题，即 在局部变量的作用域内，可用::对被屏蔽的同名的全局变量进行访问。

示例：

#include <iostream>

using namespace std;

int x = 100;
int main(int argc, char *argv[])
{
    int x = 1;
    cout << "x =" << x << endl;
    cout << "::x =" << ::x <<endl;
    return 0;
}
//x =1
//::x =100

5. 命名空间

在 c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的 c++库时，这些标识符的命名发生冲突，标准 c++引入关键字 namespace（命名空间/名字空间/名称空间），可以 更好地控制标识符的作用域。

5.1 定义

作用：封装多个变量、函数等，更好地控制标识符的作用域。

关键字：namespace

语法：

namespace [名称] {
    成员的声明，可以具有初始化的值;
    [ 
    	内部嵌套 namespace {};
    ] 
    [声明成员函数]
    [定义成员函数]
} 

// 实现namespace中声明的函数
函数返回值类型 命名空间的名称::声明的函数名(形参列表)
{
	
}

比如:
namespace A{
	int num = 10;
	void test01();
	namespace B{
		int num02;
	}
}

注意：

  • 命名空间不能定义在函数中，只能定义在全局区域

示例：

#include <iostream>

using namespace std;

namespace A {
    int num01 = 10;
    void test01()
    {
        cout << "test01进来了" << endl;
    }
    void test02();//当前命名空间中 test02这个函数只声明了，没有实现

    namespace B {
        int num02;
    }
}

//实现A命名空间中的test02函数
void A::test02()
{
    cout << "test02进来了" << endl;
}

int main(int argc, char *argv[])
{
    //命名空间名::变量名或函数名或嵌套的命名空间名称
    cout << "A::num01=" << A::num01 << endl;
    cout << "A::B::num02=" << A::B::num02 << endl;
    A::test01();
    A::test02();
    return 0;
}

//A::num01:10
//A::B::num02:0
//test01进来了
//test02进来了

5.2 注意

5.2.1 命名空间只能在全局区域定义(命名空间不能定义在函数中)

示例：

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{ 
    namespace A {
		int a = 10;
	} 
    cout << A::a << endl;
	return 0;
} 
//此时报错
5.2.2 命名空间嵌套命名空间

命名空间中可以嵌套命名空间

示例：

#include <iostream>

using namespace std;
namespace A {
    int a = 10;
    namespace B {
    	int b = 20;
    } 
} 
int main(int argc, char *argv[])
{ 
    cout << "A::a" <<A::a << endl;
	cout << "A::B::b" << A::B::b << endl;
    return 0;
}
//10
//20
5.2.3 命名空间的开放性

随时添加新的成员

示例：

#include <iostream>

using namespace std;

namespace A {
    int num01 = 10;
}

//命名空间A中再次定义一个变量num02
namespace A {
    int num02 = 10000;
}

int main(int argc, char *argv[])
{
    cout << "A::num01=" << A::num01 << endl;    //A::num01=10
    cout << "A::num02=" << A::num02 << endl;    //A::num02=10000
    return 0;
}
5.2.4 无名命名空间

无名命名空间，意味着命名空间中的标识符 只能在本文件内访问

示例：无名命名空间中的内容 当成员使用，不用加 空间名称:: 。

#include <iostream>

using namespace std;

namespace {
    int num03 = 99999;
}

int main(int argc, char *argv[])
{
    cout << "num03=" << num03 << endl;    //num03=99999
    return 0;
}
5.2.5 取别名

示例：

#include <iostream>

using namespace std;

namespace XXXXXXXXXXXXXXXXX {
    int num04 = 6666;
}

int main(int argc, char *argv[])
{
    //给 命名空间取别名
    namespace B = XXXXXXXXXXXXXXXXX;
    cout << "B::num04=" << B::num04 << endl;    //B::num04=6666
    return 0;
}

5.3 using 关键字作用

5.3.1 using声明命名空间中的具体成员
语法:
	using 命名空间名 :: 变量名

示例：

#include <iostream>

using namespace std;

namespace A{
int a = 10;
int b = 1;
}
int main(int argc, char *argv[])
{
    //声明命名空间A中的a变量
    using A::a;

    //使用时可以省略空间名::
    cout << "a=" <<a << endl;   //a=10
    cout << "A::b=" << A::b << endl;    //A::b=1
    return 0;
}

注意：

  • 容易造成同范围内的命名冲突
#include <iostream>

using namespace std;

namespace A{
    int a = 10;
    int b = 1;
}
int main(int argc, char *argv[])
{
    //声明命名空间A中的a变量
    using A::a;
    int a = 200; //命名冲突，报错

    //使用时可以省略空间名::
    cout << "a=" << a << endl;   //a=10
    cout << "A::b=" << A::b << endl;    //A::b=1
    return 0;
}
5.3.2 using声明成员函数 遇到函数重载
#include <iostream>

using namespace std;

namespace A{
    int a = 10;
    int b = 1;
    void test()
    {
        cout << "test01" << endl;
    }
    void test(int x)
    {
        cout << "test02" << endl;
    }
    void test(int x,int y)
    {
        cout << "test03" << endl;
    }
}

int main(int argc, char *argv[])
{
    //声明命名空间A中的所有test函数
    using A::test;
    test();
    test(10);
    test(1,2);
    return 0;
}

//test01
//test02
//test03
5.3.3 声明整个命名空间
#include <iostream>

using namespace std;

namespace A{
    int a = 10;
    int b = 1;
    void test()
    {
        cout << "test01" << endl;
    }
    void test(int x)
    {
        cout << "test02" << endl;
    }
    void test(int x,int y)
    {
        cout << "test03" << endl;
    }
}

//声明整个命名空间
using namespace A;

int main(int argc, char *argv[])
{
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    test();
    test(10);
    test(1,2);
    return 0;
}
//a=10
//b=1
//test01
//test02
//test03

6. 全局变量类型检测增强

#include <iostream>

using namespace std;

int a = 10;		//赋值并定义
int a; 			//c语言认为是声明,通过,c++认为是定义,报错

int main(int argc, char *argv[])
{
    cout << "Hello World!" << endl;
    return 0;
}

7. c++中所有的变量和函数都必须有类型

  • c 在自定义函数时，形参变量可以没有数据类型，即为任意类型，警告但是可以编译通过，并可以运行

  • c++中，函数的 形参变量必须指定类型。没有形参建议写void

c 语言代码：

#include <stdio.h>
//c语言中形参可以没有数据类型,此时形参可以为任意类型
//c++中形参必须有类型,没有形参建议写void
void fun(i)
{ 
    printf("%d\n",i);
} 
int main(int argc, char const *argv[])
{ 
    fun(10);
	return 0;
}

c++ 函数形参没有数据类型，会报错

8. 更严格的类型转换

在c++中，不同类型的变量之间赋值时，需要明确的类型转换。基本类型小转大除外

c 语言代码：动态开辟内存，在c中不强转没问题

#include <stdio.h>

int main(int argc, char *argv[])
{
    // 按c的方式自动转换
    int a = 65;
    char b = a;
    printf("%c\n",b);  //A
    // 在c中没有问题
    char *p = malloc(32);
    strcpy(p, "jerry");
    return 0;
    return 0;
}

c++代码：动态开辟内存，在c++中必须强转，不然会报错

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

int main(int argc, char *argv[])
{
    // 按c的方式自动转换
    int a = 65;
    char b = a;
    cout << "b=" << b << endl;
    // c++必须强转（明确数据类型）,c语言可以不用
    char *p = (char *)malloc(32);
    strcpy(p, "jerry");
    cout << "p=" << p << endl;
    return 0;
}

9.struct类型加强

  • c 中定义 结构体变量 需要加上 struct 关键字， c++不需要。
  • c 中的结构体只能定义成员变量，不能定义成员函数。 c++ 既 可以定义成员变量，也可以定义成员函数。

示例1：结构体变量不需要加 struct

#include <iostream>
using namespace std;
struct Stu
{ 
    int id;
	char name[30];
};
int main(int argc, char const *argv[])
{ 
    //c语言的写法
    //struct Stu s1 = {18,"张三"};
    //c++中定义结构体变量可以省略struct不写
    Stu s = {1, "jerry"};
    cout << "id=" << s.id << ", name=" << s.name << endl;
    return 0;
}

示例2：struct类型中可以有成员函数

#include <iostream>

using namespace std;
struct Stu
{
    int age;
    char name[40];
    //c语言中结构体中不能定义函数
    //c++对其进行增强,使其可以定义函数
    void eat()
    {
        cout << name << "干饭" << endl;
    }
};
int main(int argc, char *argv[])
{
    cout << "Hello World!" << endl;
    
    s1.eat();	//张三干饭
    return 0;
}

10. 新增bool类型关键字

  • 标准c++的bool 类型有两种内建的常量 true(转换为整数1) 和 false(转换为整数0)；
  • 非标准c++ 的 bool类型有两种内建的常量 true(转换为非0) 和 false(转换为整数0)；
  • 占1字节。

示例：

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    bool b1 = true;
    bool b2 = false;
    cout << "b1 = " << b1 << endl;
    cout << "b2 = " << b2 << endl;
    cout << "sizeof(bool)" << sizeof(bool) << endl;
    return 0;
}

//b1 = 1
//b2 = 0
//sizeof(bool)1

11. 三目运算符功能增强

  • c中三目运算表达返回是变量的 值，
  • 而c++中，三目运算表达式返回是变量(地址)

示例：

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    int a = 10;
    int b = 20;

    //c语言编译失败
    //c++成功
    /*
        c取的是a的值，所以以下代码在c中报错
        c++取的是a的地址，在c++成立
    */

    (a>b?a:b) = 100;
    cout << "a=" << a << endl; //a=10
    cout << "b=" << b << endl; //a=100
    return 0;
}

12. const(重要)

12.1 c语言中const修饰的变量为只读变量

#include <stdio.h>

int main(int argc, char *argv[])
{
    //使用const修饰变量,此时该变量为只读变量
    //只读变量:只能读取该变量的值,但是不能通过该变量对其值进行修改
    const int a = 10;
    printf("%d\n",a); //10
    //a = 1;
    int *p = &a;
    *p = 1;
    printf("%d\n",a); //1
    return 0;
}

12.2 c++中以常量初始化const变量 产生符号常量表

c++中以常量初始化const变量，不会立即开辟空间，而是 产生符号常量表，当对其取地址会开辟新的内存地址 。

#include <iostream>

using namespace std;

void fun01()
{
    const int num = 10;
    //此时num在符号常量表中,所以也无法通过变量名修改其值
    //num = 11;
    //当对该变量获取地址值,会为其开辟新的内存地址
    int *p = (int *)&num;
    *p = 11;
    cout << "num =" << num << endl;     //num =10
    cout << "*p =" << *p << endl;       //*p =11
}

int main(int argc, char *argv[])
{
    fun01();
    return 0;
}

12.3 c++中以变量初始化const变量 不产生符号常量表，立即开辟空间

示例：

#include <iostream>

using namespace std;

void fun02()
{
    int num = 10;
    const int a = num;
    // c++中const修饰变量 如果以变量初始化该变量, 会立即开辟空间不会产生符号常量表
    int *p = (int *)&a;
    *p = 11;
    cout << "a =" << a << endl;     //num =11
    cout << "*p =" << *p << endl;       //*p =11
}

int main(int argc, char *argv[])
{
    fun02();
    return 0;
}

12.4 const修饰的是自定义类变量，立即开辟空间，不产生符号常量表

示例：

#include <iostream>

using namespace std;

struct Stu
{
    int age;
    char name[30];
};

void fun03()
{
    const Stu s1 = {18, "张三"};
    //s1.age = 19;
    cout << s1.age << endl;     //18
    Stu *p = (Stu *)&s1;
    p->age = 20;
    cout << s1.age << endl;     //20
}
int main(int argc, char *argv[])
{
    fun03();
    return 0;
}

12.5 gcc 99/g++ 11编译器中const修饰的变量可以作为数组创建时的长度,c不行

不建议使用

const int x = 10;
int nums[x] = {0};

12.6 尽量使用const替代无参宏

  1. const 有类型，可进行编译器类型安全检查。#define 无类型,不可进行类型检查
  2. const 有作用域，而#define 不重视作用域。

示例：

#define NUM 97
void fun05()
{
    int x = NUM;
    char c = NUM;

    const int num01 = 10;
    int a = num01;
    char c1 = num01;  //报错

    // char *p = num01; //报错
}

13. 引用(重要)

13.1 概述

  • 变量名实质上是一段 连续内存空间 的别名，通过变量来命名一片空间对一段连续的内存空间只能取一个别名吗？

    int nums[10] = {0};	//nums存储的是一段连续内存空间的首地址

  • c++中新增了引用的概念，引用 可以作为一个 已定义的变量的 别名。

  • 引用是 c++对 c 的重要扩充，并不是 c++的发明。

13.2 语法

数据类型& 别名(变量名) = 变量;

int num = 10；
int& p = num;

13.3 注意

  1. & 在此不是求地址运算，而是 起标识作用。

  2. 类型标识符 是指 目标变量的类型

  3. 必须在 声明引用变量时进行初始化。

  4. 引用初始化之后不能改变。

  5. 不能有 NULL 引用，必须确保引用是和一块合法的存储单元关联。

    int& p = NULL; //报错

  6. 可以建立对数组的引用。

13.4 示例1：认识引用

#include <iostream>

using namespace std;
void fun01()
{
    int num = 10;
    //一个变量可以有 n 个别名
    int& p = num;

    p = 20;
    cout << "num=" << num << endl;  //num=20
    cout << "p=" << p << endl;      //p=20

    num = 30;
    cout << "num=" << num << endl;  //num=30
    cout << "p=" << p << endl;      //p=30
}

int main(int argc, char *argv[])
{
    fun01();
    return 0;
}

13.5 示例2：使用引用的注意事项

void test02()
{ 
    //1) 引用必须初始化
    int& ref; //报错:必须初始化引用
    //2) 引用一旦初始化，不能改变引用
    int a = 10;
    int b = 20;
    int& ref = a;
    ref = b; //不能改变引用
    //3) 不能对数组直接建立引用
    int arr[10];
    int& ref3[10] = arr;
}

13.6 示例3：建立数组引用

void fun02()
{
    int nums[10] = {0};

    //不能对数组直接建立引用
    //int& ns[10] = nums; //报错

    //数组建立引用，方式一
    typedef int arr[10];
    arr& list = nums;

    //数组建立引用，方式二
    int (&ns)[10] = nums;
}

13.7 示例4:建立指针变量的引用

int num = 10;
int *p = &num;
int *&myP = p;
cout<<"*myP = "<< *myP<< endl;

13.8 示例5:给函数取别名

#include <iostream>

using namespace std;

void add(int a, int b)
{
    cout << a << "+" << b << "=" << a+b << endl;
}

void fun03()
{
    void (&myfun)(int a, int b) = add;
    myfun(12,34);
}

int main(int argc, char *argv[])
{
    fun03();
    return 0;
}
//12+34=46

13.9 函数中的引用

13.9.1 引入
#include <iostream>

using namespace std;
void fun01(int a)
{
    a = 10;
}

void fun02(int *c)
{
    *c = 100;
}

int main(int argc, char *argv[])
{
    //值传递，在fun01函数里修改值，不会影响实参
    int b = 1;
    fun01(b);
    cout << "b=" << b << endl; //b=1
    //地址传递，在fun02函数里修改值，会影响实参
    fun02(&b);
    cout << "b=" << b << endl; //b=100
    return 0;
}
13.9.2 引用作为形参

当函数中的 形参是引用时，是地址传递，类似于指针

引用作为函数的参数优点：

1、实参不用取地址

2、引用（形参）不会另辟空间（不占空间）

3、函数内部 不需要指针解引用

示例：引用作为 形参

#include <iostream>

using namespace std;

void fun03(int& d)
{
    d = 1000;
}

int main(int argc, char *argv[])
{
    int b = 10;
    fun03(b);
    cout << "b=" << b << endl; //b=1000
    return 0;
}
13.9.2 引用作为返回值

注意：

  • 当函数中的 返回值为引用 时，要确保当 函数执行完毕后 ，引用关联的内存一定要存在
    • 可以用static 修饰 要返回的内容；
    • 也可以用 动态开辟内存 保证内存不被回收，后面再手动释放。

示例：函数不要返回局部变量的引用

#include <iostream>

using namespace std;

int& fun04()
{
    //此时，p指向的是num在栈区的内存地址，函数结束可能已经自动回收
    //所以在外边可能接收不到
    //int num = 10000;

    //static修饰则会改善内存可能自动回收的问题
    static int num = 10000;
    int& p = num;
    return p;
}

int main(int argc, char *argv[])
{
    int& num = fun04();
    cout << "num=" << num << endl; //num=10000
    return 0;
}

示例2：链式编程

struct Person
{
    char name[50];
//    void eat(char* foodName)
//    {
//        cout << name << "吃" << foodName << endl;
//    }
    Person& eat(Person& p, char* foodName)
    {
        cout << p.name << "吃" << foodName << endl;
        return p;
    }
};

void fun12()
{
    Person p = {"张三"};
    //张三吃油泼面,张三吃甑糕,张三吃棒棒糖
//    p.eat("油泼面");
//    p.eat("甑糕");
//    p.eat("棒棒糖");
    p.eat(p,"油泼面").eat(p,"甑糕").eat(p,"棒棒糖");
}

13.10 常引用

13.10.1 概念

概念：常量的引用

特点：值不能被修改

13.10.2 示例
void test07(void)
{ 
    const int& num = 10;
	num = 11;//err 不能被修改
}
13.10.3 常引用作为函数的参数

作用：防止函数内部 通过引用修改外部的值

优点：

  • 引用不产生新的变量，减少形参与实参传递时的开销。
  • 由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用。
  • 如果希望 实参随着形参的改变而改变，那么使用 一般的引用
  • 如果不希望实参随着形参改变，那么使用常引用

示例：

void fun05(const int& num)
{
    //num = 1000000; //报错，只读，不能修改
    cout << num << endl;
}

int main(int argc, char *argv[])
{
    int num = 100;
    fun05(num);
    cout << "num=" << num << endl; //num=100
    return 0;
}

14. 内联函数

14.1 概念

由关键字 inline 修饰的函数 为内联函数。

示例：

inline void add(int a,int b)
{
	cout << a+b << endl;
} 
int main()
{
    //add(10,2);
    cout << 10+2 << endl;
}

14.2 特点

内联函数：在编译阶段像宏一样展开。有作用域的限制（作为类的成员函数）。

内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以进行参数、返回值类型的安全检查，又可以作为成员函数。

14.3 注意

  • inline只能在定义函数的时候修饰。
  • 任何在类内部定义的函数自动成为内联函数。
  • inline修饰的函数是否为内联函数，取决于编译器。对于非inline修饰的函数，也有可能转成内联函数（体积小、功能简单的函数）。

14.4 内联的条件

不能存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对函数进行取址操作

14.5 宏函数和内联函数区别（重要）

宏函数：

  • 参数没有类型，不能保证参数的完整型。
  • 宏函数 在 预处理阶段 展开。
  • 宏函数 没有作用域限制 不能作为类的成员。

内联函数：

  • 参数有类型 保证参数的完整型。
  • 内联函数 在 编译阶段 展开。
  • 内联函数 有作用域限制 能作为类的成员

15. 形参的默认值

概念：

c++在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值，
当函数 调用的时候如果没有指定这个值，编译器会自动用默认值代替。

注意：

  • 如果某形参 设置了默认参数，那么这个形参的 后边所有形参都必须设置默认参数。

示例：

void test10(int a = 1,int b = 10)
{ 
    cout << "a = " << a << endl;
	cout << "b = " << b << endl;
} 
int main(int argc, char *argv[])
{ 
    test10();
	return 0;
}

16. 占位参数

概念:

只有形参类型 没有形参名的参数 叫占位参数。

示例：

void test11(int a,int)
{ 
    cout << "a = " << a << endl;
} 
void test12(int a,int=10)
{ 
    cout << "a = " << a << endl;
} 
int main(int argc, char *argv[])
{ 
    test11(1,2);
	return 0;
}

注意：

  • 占位参数、 重载++、 – 运算符才用。

17. 函数重载

函数重载 是静态多态。

函数重载：一个函数名 多个函数功能。

函数重载的条件：同一作用域，函数的参数个数、类型、顺序不同都可以重载，返回值类型不能作为重载条件。

示例：

void test13()
{ 
    cout << "test13-01" << endl;
} 
void test13(int i)
{ 
    cout << "test13-02" << endl;
}
void test13(int i,char c)
{ 
    cout << "test13-02" << endl;
}

17.1 底层原理

因为c++在编译函数时会在函数名前随机添加新的名称, 所以此时test13函数将生成以下函数名

	如:
        _Z4test13v //v代表无返回值
        _Z4test13i //i为参数类型的首字母
        _Z4test13ic //i为第一个参数类型的首字母,c为第二个参数类型的首字母

注意：函数重载和缺省参数 在一起 容易产生二义性

#include <iostream>

using namespace std;
void test14(int a)
{
    cout << "test14-01" << endl;
}
void test14(int a,int b=10)
{
    cout << "test14-01" << endl;
}

int main(int argc, char *argv[])
{
    //error: call of overloaded 'test14(int)' is ambiguous
    //调用重载的test14(int)是二义性的
    test14(12);
    return 0;
}

18. 混合编程

由于 c++可以使用c的模块中函数，当c++整个工程编译时，可能会将使用c语言编写的函数名编译成c++规则的函数名（定义的函数名前随机添加新的名称），链接程序时，可能会找不到目标函数，因此采用 extern "c" 解决。

c 函数: void MyFunc(){} ，被编译成函数: MyFunc
c++函数: void MyFunc(){}，被编译成函数: _Z6Myfuncv

错误演示：

//test.h
#ifndef TEST_H
#define TEST_H
extern void test(int x);
#endif // TEST_H



//test.c
void test(int x)
{ } 

//main.cpp
#include <iostream>
#include "test.h"
using namespace std;
int main(int argc, char *argv[])
{
    test();
    return 0;
}

修改：

//test.h
#ifndef TEST_H
#define TEST_H

#ifdef __cplusplus
extern "c"{
#endif
    
extern void test(int x);
    
#ifdef __cplusplus
} 

#endif
#endif // TEST_H
小玖工作坊
关注
  • 13
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++与C语言的差异（第一弹）
qq_46664080的博客
11-07 318
C++动态数组与C语言动态内存分配，auto自动类型，C++string类与C语言的char arr[]数组，基于范围的for()循环。
C++与C语言的区别
qq_41258050的博客
03-03 7437
1.C++的创建历程： 20世纪70年代中期，Bjarne Stroustrup在剑桥大学计算机中心工作。他使用过Simula和ALGOL，接触过C。他对Simula的类体系感受颇深，对ALGOL的结构也很有研究，深知运行效率的意义。既要编程简单、正确可靠，又要运行高效、可移植，是Bjarne Stroustrup的初衷。以C为背景，以Simula思想为基础，正好符合他的设想。1979年，Bjam...
C与C++库差异
qq_19461303的博客
09-17 212
严格区分c和c++的语法是相当有必要的，可以有效的避免一些非逻辑性的bug
C语言与C++的区别浅析
m0_65787494的博客
04-16 1177
C与C++区别浅析
C++ 开发环境设置
m0_73557448的博客
02-01 1489
本节介绍了三种C++编译工具，其中DEV-C++和Visual Studio 2022有着详细的安装、创建步骤，为后面的学习提供帮助。
C++性能优化笔记-6-C++元素的效率差异-7-类型转换
工作学习记录
11-03 1887
C++元素的效率差异类型转换signed与unsigned转换整数大小转换浮点精度转换整数到浮点转换浮点到整数转换指针类型转换重新解释对象的类型const_caststatic_castreinterpret_castdynamic_cast转换类对象 类型转换 在C++语法中，有几种方式进行类型转换： // Example 7.19 int i; float f; f = i; // Implicit type conversion f = (float)i; // C-style t
C++性能优化笔记-6-C++元素的效率差异-11-结构体和类
工作学习记录
09-06 926
C++元素的效率差异结构体和类类数据成员类成员函数(方法)虚函数运行时类型识别(RTTI)继承构造函数与析构函数 结构体和类 时至今日，编程教材推荐面向对象编程，作为使软件更清晰及模块化的一种手段。所谓的对象是结构体及类的实例。面向对象编程形式对程序性能有积极与消极的影响。 积极的影响有： 一起使用的变量也保存在一起，如果它们是结构体或类的成员。这使得数据缓存更高效。 作为类成员的变量无需作为参数传递给类成员函数。这些变量避免了参数传递的开销。 消极影响有： 一些程序员把代码分到太多的小的类中。这是低
C++性能优化笔记-6-C++元素的效率差异-18-预处理和命名空间
工作学习记录
09-08 157
C++元素的效率差异预处理指令命名空间 预处理指令 就程序性能而言，预处理指示（所有以#开头的东西）是没有代价的，因为它们在程序编译前被解决了。 #if指令用于支持多平台或同一个源代码的多种配置。#if比if更高效，因为#if在编译时解析，而if在运行时。 在用于定义常量时，#define等价于const定义。例如，#define ABC 123与const int ABC = 123;一样高效，因为在大多数情形里，优化的编译器会用值替换一个整数常量。不过，在某些情形里，const int声明需要内存空间，
C语言与C++语言相互调用
热门推荐
Andy的博客
10-17 2万+
C语言与C++语言相互调用 1 C++调用C中的函数 1.1 C++调用C中的函数（正确使用） 1、案例源文件组成 ...
【C++/C】C++与C指针使用方法及差异（二）：差异
卡兹戴尔
04-03 2788
C++/C之间指针使用的差异
C++与C的差异分析
09-04
主要介绍了C++与C的差异分析,非常实用,需要的朋友可以参考下
C和C++ const的声明差异
12-26
但若要获取与 C++ 中相同的行为，则必须将 const 变量声明为： extern const int i = 2; 如果希望在 C++ 源代码文件声明用于 C 源代码文件的 extern 变量，请使用： extern "C" const int x = 10; 以防止 C++ ...
C语言与C++的主要区别是什么
08-27
本文介绍了C语言和C++两种编程语言的主要区别。其中最显著的区别之一就是C++支持面向对象的特性和STL标准库等高级特性，而C语言不支持。此外，C++还增加了一些新的数据类型和函数库，使得程序员能够更方便地进行编程...
C与C++差异
08-10
这篇文章主要总结了C与C++的差异性，希望对大家有所帮助
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1008
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 145
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 692
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 323
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 289
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
c++教程-c++视频教程+源码合集
06-06
c语言是一种非常基础的编程语言，而掌握c语言对于计算机科学领域的从业者来说是必不可少的。在学习c语言时，除了阅读书籍和文档外，更好的方式是参考一些c编程的源代码示例，并且根据这些示例编写自己的代码来巩固学习成果。本文呈现的是c语言教程视频，其中包含了很多c语言编程实例，使那些有兴趣学习c语言的朋友能够从基础到深入地学习编程知识。 在这些视频教程中，会涵盖c语言的基本语法、数据类型、变量、运算符等基础知识，同时也会介绍一些高级的c语言技术，如指针、结构体、函数指针以及文件输入输出。不仅如此，这些视频还会演示如何使用c语言编写一些实用的程序，如文本编辑器、计算器、迷宫游戏等等。 所有这些视频都包括了源代码以及所需软件的下载链接，使观众能够在自己的计算机上实际运行这些程序，并且通过自己的实践进行进一步的学习和实践。 对于那些有志于学习c语言并且希望得到一些实践经验的朋友，这些视频将是一个非常有价值的资源。透过视频学习可以让学习状况更生动有趣、更富有实践经验，因此对于初学者来说更容易理解和学习。大量源码案例集合在一起也可快速适应或了解各种应用实现上的差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值