C++中的结构、联合和枚举
1.结构
和C语言的不同：
1)定义结构型变量时，可以省略struct关键字。
2)结构内部可以定义函数——成员函数。
3)sizeof (空结构) -> 1
例子：
#include <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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;
}
予人玫瑰,手有余香,小羊伴你一路同行~~~,谢谢大家的关注