C语言到C++的过渡(加强部分)

C++中的结构、联合和枚举

1.结构

和C语言的不同:

1)定义结构型变量时,可以省略struct关键字。

2)结构内部可以定义函数——成员函数。

3)sizeof (空结构) -> 1

例子:

#include 
using namespace std;
struct Student {
char name[128];
int age;
void who (void) { //成员函数
cout << "我叫" << name << ",今年" << age
<< "岁了。" << endl;
}
};
int main (void) {
Student student = {"张飞", 25}, *ps = &student;
student.who ();
ps->who ();
struct A {};
cout << sizeof (A) << endl;
return 0;
}

-----------------------------------------------------------

2.联合

增加了匿名联合的概念。借用联合语法形式,

描述一些变量在内存中的布局方式。

int main()
{
UNION
{
int a;
char ch[4];
};
a=0x12345678;
}

定义联合变量时,可以不加union

例子:

#include 
using namespace std;
int main (void) {
// 匿名联合
union {
int x;
char c[4] /*= {'A', 'B', 'C', 'D'}*/;
};
cout << (void*)&x << ' ' << (void*)c << endl;
x = 0x12345678;
for (int i = 0; i < 4; ++i)
cout << hex << (int)c[i] << ' ';
cout << endl;
return 0;
}


---------------------------------------------------


3.枚举

枚举是一个独立的数据类型。

C:

enum E {a, b, c};
enum E e;
e = a;
e = 1000;
C++:
enum E {a, b, c};
E e;
e = a;
e = b;
e = c;
b=1; // ERROR !
e = 1000; // ERROR !
e = 1; // ERROR !

例子:

#include 
using namespace std;
int main (void) {
enum E {a, b, c};
E e;
e = a;
e = b;
e = c;
// e = 1000;//报错
// e = 1; //报错 return 0;}

七、C++的布尔类型,跟在cout后面可以boolalpha

bool b = true;
b = false;
cout << sizeof (b) << endl; // 1
b = 100;
b = 1.234;
b = "hello";
b = 'A';

八、C++中的运算符别名

&& - and

|| - or

& - bitand

^ - xor

{ - <%

} - %>

[ - <:

] - :>

九、C++中的函数

1.重载:条件

在同一个作用域中,

函数名相同,

参数表不同的函数,

构成重载关系。


C++编译器会对程序中的函数做换名,

将参数表中的类型信息汇合到函数名中,以保证函数名的唯一。

通过extern "C",可以要求编译器不做C++换名,以方便在C语言的模块中使用C++编译生成的代码。

方式一:

extern "C" {
int add (int a, int b) {
return a + b;
}
int sub (int a, int b) {
return a - b;
}
}
方式二:
extern "C" int add (int a, int b, int c) {
return a + b + c; }

2.缺省参数和哑元参数

1)如果调用一个函数时,没有提供实参,那么对应形参就取缺省值。

2)如果一个参数带有缺省值,那么它后边的所有参数必须都带有缺省值。

3)如果一个函数声明和定义分开,那么缺省参数只能放在声明中

4)避免和重载发生歧义。

5)只有类型而没有名字的形参,谓之哑元。

i++ - operator++

++i

V1: void decode (int arg) { ... }

V2: void decode (int) { ... }

例子1:重载与缺省值

#include 
using namespace std;
void foo (int a = 10, double b = 0.01,
const char* c = "tarena"); //函数1
void foo (void) {} //函数2
//函数1与函数2构成重载关系
void bar (int) { //函数3
cout << "bar(int)" << endl;
}
void bar (int, double) { //函数4
cout << "bar(int,double)" << endl;
}
//函数3与函数4构成重载关系
int main (void) {
foo (1, 3.14, "hello");//调用函数1
foo (1, 3.14); //调用函数1

foo (1); //调用函数1
// foo (); // 歧义 ,可以调用函数2,但也可以调用函数1,因为函数1在不提供实参的情况下,可以取缺省值。
bar (100); //调用函数3
bar (100, 12.34); //调用函数4
return 0;
}

--------------------------------------

例子2:重载与作用域

#include 
using namespace std;
namespace ns1 {
int foo (int a) { 函数1
cout << "ns1::foo(int)" << endl;
return a;
}
};
namespace ns2 {
double foo (double a) { 函数2
cout << "ns2::foo(double)" << endl;
return a;
}
};
int main (void) {
using namespace ns1; // 名字空间指令
using namespace ns2; // 名字空间指令
cout << foo (10) << endl; //10 调用函数1,作用域可见ns2与ns1,所以与函数2构成重载
cout << foo (1.23) << endl; //1.23 调用函数2,作用域可见ns2与ns1,所以与函数1构成重载



using ns1::foo; //名字空间声明
(当同时出现名字指令与名字空间声明,则名字空间声明会隐藏名字空间指令)
cout << foo (10) << endl; //10,调用函数1,只可见名字空间ns1的foo(),所以也并不构成重载。

cout << foo (1.23) << endl; //10,调用函数1,只可见名字空间ns1的foo(),所以也并不构成重载。

using ns2::foo; //名字空间声明
cout << foo (10) << endl; //10,调用函数1,可见名字空间ns1与名字空间ns2的foo(),所以构成重载。

cout << foo (1.23) << endl; //1.23,调用函数2,可见名字空间ns1与名字空间ns2的foo(),所以构成重载。
return 0;
}

--------------------------------------------------------

3.内联

1)编译器用函数的二进制代码替换函数调用语句,减少函数调用的时间开销。这种优化策略成为内联。

2)频繁调用的简单函数适合内联,而稀少调用的复杂函数不适合内联。

3)递归函数无法内联

4)通过inline关键字,可以建议编译对指定函数进行内联,但是仅仅是建议而已。

inline void foo (int x, int y){...}


十、C++的动态内存分配

malloc/calloc/realloc/free(在一定条件下可以混搭)

1.new/delete:对单个变量进行内存分配/释放

2.new[]/delete[]:对数组进行内存分配/释放

例子:new与delete

#include 
using namespace std;
int main (void) {
// int* pi = (int*)malloc (sizeof (int));
// free (pi); //c中的方法
int* pi = new int;
*pi = 1000;
cout << *pi << endl;
delete pi; //一定要释放内存,否则会造成内存泄露,很严重
pi = NULL; //不要忘记这个,虽然不会报错,但是要有好习惯
/*
*pi = 2000;
cout << *pi << endl; //pi指向的内存地址已经被释放,被初始化为指向NULL
*/
pi = new int[10];
for (size_t i = 0; i < 10; ++i)
pi[i] = i;
for (size_t i = 0; i < 10; ++i)
cout << pi[i] << ' ';
cout << endl;
delete[] pi; //千万记住new[]要用delete[]来释放内存
pi = NULL;
pi = new int (1234); //用new分配内存的同时初始化赋一个值。
cout << *pi << endl; //1234
delete pi;
pi = NULL;
char buf[4] = {0x12,0x34,0x56,0x78};
pi = new (buf) int;
cout << hex << *pi << endl;
// delete pi;
cout << (void*)pi << ' ' << (void*)buf << endl;
int (*p)[4] = new int[3][4];
delete[] p;
int (*q)[4][5] = new int[3][4][5];
delete[] q;
return 0;
}

予人玫瑰,手有余香,小羊伴你一路同行~~~,谢谢大家的关注

展开阅读全文

页面更新:2024-03-28

标签:歧义   内联   变量   指令   函数   例子   分配   定义   内存   声明   名字   作用   参数   语言   结构   科技   空间

1 2 3 4 5

上滑加载更多 ↓
推荐阅读:
友情链接:
更多:

本站资料均由网友自行发布提供,仅用于学习交流。如有版权问题,请与我联系,QQ:4156828  

© CopyRight 2020-2024 All Rights Reserved. Powered By 71396.com 闽ICP备11008920号-4
闽公网安备35020302034903号

Top