绪论0.1

时间：2020-06-08 19:38:26 阅读：38 评论：0 收藏：0 [点我收藏+]

采用面向过程（结构化）方法描述算法

　　本文主要是为了之后的数据结构的一些算法的描述，铺垫一些C/C++语言的知识。

数据类型

　　在用C/C++语言编写的程序中必须对出现的每个变量、常量、或表达式明确地说明它们所属的数据类型。

　　（1） C/C++语言中的常见数据类型（预定义类型）

　　这些数据类型大致可以分为整型、字符型、布尔型、浮点型和空类型。（还有一些修饰词的类型如：short、long等）。在C++中有一个字符串类型它与C的字符串类型有一些不一样，具体体现在相关的字符串函数。

　　当然除了上述提到的类型，还有许多不常用的，如C++11x新增的类型char16_t和char32_t等。wchar_t来自typedef short int wchat_t。不同编译器和系统可能存在差异。

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 到 18,446,744,073,709,551,615
float	4 个字节	精度型占4个字节（32位）内存空间，+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	双精度型占8 个字节（64位）内存空间，+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	长双精度型 16 个字节（128位）内存空间，可提供18-19位有效数字。
wchar_t	2 或 4 个字节	1 个宽字符
bool	1	1,0

　　（2）C/C++语言中的指针类型

概念	描述
C++ Null 指针	C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。
C++ 指针的算术运算	可以对指针进行四种算术运算：++、--、+、-
C++ 指针 vs 数组	指针和数组之间有着密切的关系。
C++ 指针数组	可以定义用来存储指针的数组。
C++ 指向指针的指针	C++ 允许指向指针的指针。
C++ 传递指针给函数	通过引用或地址传递参数，使传递的参数在调用函数中被改变。
C++ 从函数返回指针	C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。

　　C/C++中的指针用法基本是一致的，这里不做详细说明。在C++中有一个经常用到的tish指针，C中似乎没有。

char* p = &v[3]; //p指向v的第4个元素

　　技术分享图片

　　（3）C/C++语言中的数组类型

　　数组是一种基本的数据类型，在后述篇章中有详细的描述。这里只简单提一下。在C++中字符串数组有许多相应的函数是C中没有的。例如:.apend()、.toString()、等等。

概念	描述
多维数组	C 支持多维数组。多维数组最简单的形式是二维数组。
传递数组给函数	您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
从函数返回数组	C 允许从函数返回数组。
指向数组的指针	通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。

　　（4）C/C++语言中的枚举类型

　　enum　枚举名　{枚举元素1,枚举元素2,……};

enum DAY{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

　　枚举变量的定义：

　　①先定义枚举类型，再定义枚举变量

enum DAY{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};enum DAY day;

　　②定义枚举类型的同时定义枚举变量

enum DAY{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

　　③省略枚举名称，直接定义枚举变量

enum{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

　　将整型数转换为枚举：

#include <stdio.h> 
#include <stdlib.h> 
int main() { 
    enum day { saturday, sunday, monday, 
    tuesday, wednesday, thursday, friday } workday; 
    int a = 1; 
    enum day weekend; 
    weekend = ( enum day ) a; //类型转换
     //weekend = a; //错误 
    printf("weekend:%d",weekend); 
    return 0; 
}

　　（5）C/C++语言中的结构体类型

　　定义结构：

struct type_name {
     member_type1 member_name1; 
     member_type2 member_name2; 
     member_type3 member_name3; 
    . . 
} object_names;

　　结构体变量的初始化：

#include<iostream> 
using namespace std;

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 语言", "RUNOOB", "编程语言", 123456};
 
int main()
{
    cout<< "title : " << book.title <<endl;
    cout<< "subject : " << book.subject <<endl;
    cout<< "author : " << book.author <<endl;
    cout<< "book_id : " << book.book_id <<endl;
    return 0;
}

　　运行示例：

title : C 语言
subject : 编程语言
author : RUNOOB
book_id : 123456

　　访问结构成员：结构作为函数参数：你可以把结构作为函数参数，传参方式与其他类型或指针类型。结构体作为函数参数。

#include <iostream>
#include <cstring>
using namespace std;
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   cout << "Book 1 title : " << Book1.title << endl;
   cout << "Book 1 author : " << Book1.author << endl;
   cout << "Book 1 subject : " << Book1.subject << endl;
   cout << "Book 1 book_id : " << Book1.book_id << endl;
 
   /* 输出 Book2 信息 */
   cout << "Book 2 title : " << Book2.title << endl;
   cout << "Book 2 author : " << Book2.author << endl;
   cout << "Book 2 subject : " << Book2.subject << endl;
   cout << "Book 2 book_id : " << Book1.book_id << endl;
 
   return 0;
}

　　运行示例：

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495407

　　指向结构的指针

#include <iostream>
#include <cstring>
using namespace std;
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );
 
   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );
 
   return 0;
}
void printBook( struct Books *book )
{
   cout << "Book title : " << book->title << endl;
   cout << "Book author : " << book->author << endl;
   cout << "Book subject : " << book->subject << endl;
   cout << "Book book_id : " << book->book_id << endl;
}

　　位域定义与结构定义相仿，其形式为：

struct //位域结构名 
{
 //位域列表：类型说明符 位域名: 位域长度

};

　　位域的定义和位域变量的说明

struct bs{
    unsigned a:4;
    unsigned  :4;    /* 空域 */
    unsigned b:4;    /* 从下一单元开始存放 */
    unsigned c:4
}

　　位域的使用

#include <iostream>
using namespace std;

struct bs{
    unsigned a:1;
    unsigned b:3;
    unsigned c:4;
} bit,*pbit;

int main(void){    
    bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    cout << bit.a << ‘,‘ << bit.b << ‘,‘ << bit.c << endl;    /* 以整型量格式输出三个域的内容 */
    pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */
    pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */
    pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
    pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
    cout<< pbit->a << ‘,‘ << pbit->b << ‘,‘ << pbit->c <<endl;    /* 用指针方式输出了这三个域的值 */
    return 0;
}

　　运行示例：

1,7,15
0,3,15

　　typedef关键字：你可以为创建的类型取一个“别名”。例如：

typedef struct Books{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
}Books;

　　现在，你可以直接使用Books来定义Books类型的变量，而不是使用struct关键字。如下：

Books Book1, Book2;

　　你可以使用typedef关键字来定义非结构类型，如：

typedef long int *pint32;
pint32 x, y, z;

　　x,y,z都是指向长整形long int的指针。

　　（6）C/C++语言中的共用体类型

　　共用体是一种特殊的数据类型，允许你在相同的内存位置存储不同的数据类型。你可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。定义共用体必须使用union语句。

union [union tag] { 
    member definition; 
    member definition; 
    ... 
    member definition; 
} [one or more union variables];

　　一个变量（相同的内存位置）可以存储多个多种类型的数据。共用体占用的内存足够存储共用体中最大的成员。

union Data { 
    int i; 
    float f; 
    char str[20]; 
} data;

#include <stdio.h> 
#include <string.h> 
union Data { 
    int i; 
    float f; 
    char str[20]; 
}; 
int main( ) { 
    union Data data; 
    printf( "Memory size occupied by data : %d\n", sizeof(data)); 
    return 0; 
}

　　访问共用体成员：使用成员访问运算符（.）并且，同一时间只使用一个变量。

#include <stdio.h> 
#include <string.h> 
union Data { 
    int i; 
    float f; 
    char str[20]; 
}; 
int main( ) { 
    union Data data; 
    data.i = 10; 
    data.f = 220.5; 
    strcpy( data.str, "C Programming"); 
    printf( "data.i : %d\n", data.i);
    printf( "data.f : %f\n", data.f); 
    printf( "data.str : %s\n", data.str); 
    return 0; 
}

函数、头文件和库

　　定义函数：返回类型，函数名称、参数、函数主体。实例：

　　函数声明，函数声明会告诉编译器函数名称及如何调用函数，函数的实际主题可以单独定义。

　　函数参数：在程序中使用头文件，需要使用C/C++预处理指令#include来引用它。在比较长的程序中，建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候引用这些头文件。

调用类型	描述
传值调用	该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
引用调用	通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

　　引用头文件的语法，使用预处理#include可以引用用户和系统头文件：

　　#include <file>：引用的是编译器的类库路径里面的头文件。

　　#include “file”：引用的是你程序目录的相对路径中的头文件，如果在程序目录没有找到引用的头文件则到编译器的类库路径的目录下找该头文件。

　　引用头文件的操作：只引用一次头文件：

#ifndef HEADER_FILE
#define HEADER_FILE

the entire header file file

#endif

　　这种结构就是通常所说的包装#ifndef.当再次引用头文件时，条件为假，因为HEADER_FILE已定义。此时，预处理器会跳过文件的整个内容，编译器会忽略它。有条件引用，有时需要从多个不同的头文件中选择一个引用到程序中。例如，需要指定在不同的操作系统上使用的配置参数。您可以通过一系列条件来实现这点，如下：

#if SYSTEM_1
   # include "system_1.h"
#elif SYSTEM_2
   # include "system_2.h"
#elif SYSTEM_3
   ...
#endif

　　但是如果头文件比较多的时候，这么做是很不妥当的，预处理器使用宏来定义头文件的名称。这就是所谓的有条件引用。它不是用头文件的名称作为 #include 的直接参数，您只需要使用宏名称代替即可：

#define SYSTEM_H "system_1.h"
 ...
 #include SYSTEM_H

　　SYSTEM_H 会扩展，预处理器会查找 system_1.h，就像 #include 最初编写的那样。SYSTEM_H 可通过 -D 选项被您的 Makefile 定义。

　　在有多个 .h 文件和多个 .c 文件的时候，往往我们会用一个 global.h 的头文件来包括所有的 .h 文件，然后在除 global.h 文件外的头文件中包含 global.h 就可以实现所有头文件的包含，同时不会乱。方便在各个文件里面调用其他文件的函数或者变量。

　　C++标准库可分为两部分：

　　标准函数库：这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。

　　面向对象类库：这个库是类及其相关函数的集合。标准的 C++ I/O 类、String 类、数值类、STL 容器类、STL 算法、STL 函数对象、STL 迭代器、STL 分配器、本地化库、异常处理类、杂项支持库。

　　当然除了标准库外，还有开源的库（例如GitHub上的库文件）和程序员自己编写的库。下面笔者将展示，C++库的创建。

绪论0.1

原文：https://www.cnblogs.com/jianle23/p/13066828.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)