c++笔记2

<>和"" 头文件

<>:引用的是编译器的类库路径里面的文件
"":引用的是程序目录的相对路径的文件

static_cast<> 标准转换运算符，是一个强制类型转换操作符。

static_cast支持指向基类的指针和指向子类的指针之间的相互转换
最大作用：基础类型和对象的转换。

强制类型转换符：
        static_cast
        dynamic_cast
        const_cast
        reinterpert_cast

使用static_cast可以找回存放在void*指针中的值
double a = 1.999;
void * vptr = &a;
double * dptr = static_cast<double*>(vptr);
cout<<*dptr<<endl; //输出1.999

头文件

main.cpp->Compile(->#include<iostream>->iostream(header file))->

main.o->Link(Standard Runtime Library)->main.exe

.h文件 头文件保护符

// This is start of the header guard.  ADD_H can be any unique name.  By convention, we use the name of the header file.
#ifndef ADD_H
#define ADD_H
 
// This is the content of the .h file, which is where the declarations go
int add(int x, int y); // function prototype for add.h -- don't forget the semicolon!
 
// This is the end of the header guard
#endif

#ifdef 和 #ifndef 相反

#define PRINT_JOE
 
#ifdef PRINT_JOE
std::cout << "Joe" << std::endl;
#endif

#ifdef PRINT_BOB
std::cout << "Bob" << std::endl;
#endif
//只输出 Joe

全局变量
#include <iostream>
int value(5); // global variable
 
int main()
{
    int value = 7; // hides the global variable value
    value++; // increments local value, not global value
    ::value--; // decrements global value, not local value
 
    std::cout << "global value: " << ::value << "\n";
    std::cout << "local value: " << value << "\n";
    return 0;
} // local value is destroyed
输出：
global value: 4
local value: 8

::value表示全局变量，所以在第二个输出中，输出的是自减后的全局变量value。

static和extern

static仅限当前文件
static int g_x; // g_x is static, and can only be used within this file
 
int main()
{
    return 0;
}

extern可以在其他文件中使用
extern double g_y(9.8); // g_y is external, and can be used by other files
 
int main()
{
    return 0;
}

namespace的使用

foo.h:
namespace Foo
{
    // This doSomething() belongs to namespace Foo
    int doSomething(int x, int y)
    {
        return x + y;
    }
}

goo.h
namespace Goo
{
    // This doSomething() belongs to namespace Goo
    int doSomething(int x, int y)
    {
        return x - y;
    }
}

int main(void)
{
    std::cout << Foo::doSomething(4, 3) << '\n';
    std::cout << Goo::doSomething(4, 3) << '\n';
    return 0;
}
输出：
7
1

另一种：
add.h
namespace BasicMath
{
    // function add() is part of namespace BasicMath
    int add(int x, int y)
    {
        return x + y;
    }
}

subtract.h
namespace BasicMath
{
    // function subtract() is also part of namespace BasicMath
    int subtract(int x, int y)
    {
        return x - y;
    }
}

#include "add.h" // import BasicMath::add()
#include "subtract.h" // import BasicMath::subtract()
 
int main(void)
{
    std::cout << BasicMath::add(4, 3) << '\n';
    std::cout << BasicMath::subtract(4, 3) << '\n';
 
    return 0;
}
不同文件下可以使用相同命名的namespace

namespace也可以“赋值”：
namespace Foo
{
    namespace Goo
    {
        const int g_x = 5;
    }
}
 
namespace Boo = Foo::Goo; // Boo now refers to Foo::Goo
 
int main()
{
    std::cout << Boo::g_x; // This is really Foo::Goo::g_x
    return 0;
}

隐式类型转换

The priority of operands is as follows:

long double (highest)
double
float
unsigned long long
long long
unsigned long
long
unsigned int
int (lowest)

#include <iostream>
#include <typeinfo> // for typeid()
 
int main()
{
    short a(4);
    short b(5);
    std::cout << typeid(a + b).name() << " " << a + b << std::endl; // show us the type of a + b
 
    return 0;
}
输出：
int 9

#include <iostream>
#include <typeinfo> // for typeid()
 
int main()
{
    double d(4.0);
    short s(2);
    std::cout << typeid(d + s).name() << " " << d + s << std::endl; // show us the type of d + s
 
    return 0;
}
输出：
double 6.0

cin.ignore()的使用
在读取数字的时候，cin得到的字符串是"2\n",然后下一行在读取的时候就直接读取了"\n"，从而
影响了下一行数据的正常读入。
int main()
{
    std::cout << "Pick 1 or 2: ";
    int choice;
    std::cin >> choice;
 
    std::cin.ignore(32767, '\n'); // ignore up to 32767 characters until a \n is removed
 
    std::cout << "Now enter your name: ";
    std::string name;
    std::getline(std::cin, name);
 
    std::cout << "Hello, " << name << ", you picked " << choice << '\n';
 
    return 0;
}

string中最常用的有：
string a;
string b;
string c = a + b;

a.length();

a[0] = 'a';

std::string s1="hello world";
std::string s2="hello boy";
const char *cc1="hello girl";
const char *cc2="hello dog";
if (s1==cc1) {.....} //这是可以的
if (s1==s2) {.....}//这是可以的
if (cc1==cc2) {....}//这是错误的
if(strcmp(cc1==cc2)) {....}//这是可以的

string类的字符操作：
const char &operator[](int n)const;
const char &at(int n)const;
char &operator[](int n);
char &at(int n);
operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。
const char *data()const;//返回一个非null终止的c字符数组
const char *c_str()const;//返回一个以null终止的c字符串
int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目

string的特性描述:
int capacity()const;    //返回当前容量（即string中不必增加内存即可存放的元素个数）
int max_size()const;    //返回string对象中可存放的最大字符串的长度
int size()const;        //返回当前字符串的大小
int length()const;       //返回当前字符串的长度
bool empty()const;        //当前字符串是否为空
void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分

string类的输入输出操作:
string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。
函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。

string的赋值：
string &operator=(const string &s);//把字符串s赋给当前字符串
string &assign(const char *s);//用c类型字符串s赋值
string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值
string &assign(const string &s);//把字符串s赋给当前字符串
string &assign(int n,char c);//用n个字符c赋值给当前字符串
string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串
string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串

string的连接：
string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾 
string &append(const char *s);            //把c类型字符串s连接到当前字符串结尾
string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
string &append(const string &s);    //同operator+=()
string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string &append(int n,char c);        //在当前字符串结尾添加n个字符c
string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

string的比较：
bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较；
int compare(const string &s) const;//比较当前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函数在>时返回1，<时返回-1，==时返回0  

string的子串：
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

string的交换：
void swap(string &s2);    //交换当前字符串与s2的值

string类的查找函数： 
int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//查找成功时返回所在位置，失败返回string::npos的值 
int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值 
int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos 
int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos 
int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const; 
int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

string类的替换函数： 
string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串

string类的插入函数： 
string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c

string类的删除函数 
iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置
iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置
string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串

string类的迭代器处理： 
string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。
用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：
const_iterator begin()const;
iterator begin();                //返回string的起始位置
const_iterator end()const;
iterator end();                    //返回string的最后一个字符后面的位置
const_iterator rbegin()const;
iterator rbegin();                //返回string的最后一个字符的位置
const_iterator rend()const;
iterator rend();                    //返回string第一个字符位置的前面
rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

enum的使用：
enum Color
{
    COLOR_BLACK, // assigned 0
    COLOR_RED, // assigned 1
    COLOR_BLUE, // assigned 2
    COLOR_GREEN, // assigned 3
    COLOR_WHITE, // assigned 4
    COLOR_CYAN, // assigned 5
    COLOR_YELLOW, // assigned 6
    COLOR_MAGENTA // assigned 7
};
 
Color paint(COLOR_WHITE);
std::cout << paint;

enum Animal
{
    ANIMAL_CAT = -3,
    ANIMAL_DOG, // assigned -2
    ANIMAL_PIG, // assigned -1
    ANIMAL_HORSE = 5,
    ANIMAL_GIRAFFE = 5, // shares same value as ANIMAL_HORSE
    ANIMAL_CHICKEN // assigned 6
};

enum class

#include <iostream>
//enum情况下
int main()
{
    enum Color
    {
        RED, // RED is placed in the same scope as Color
        BLUE
    };
 
    enum Fruit
    {
        BANANA, // BANANA is placed in the same scope as Fruit
        APPLE
    };
    
    Color color = RED; // Color and RED can be accessed in the same scope (no prefix needed)
    Fruit fruit = BANANA; // Fruit and BANANA can be accessed in the same scope (no prefix needed)
 
    if (color == fruit) // The compiler will compare a and b as integers
        std::cout << "color and fruit are equal\n"; // and find they are equal!
    else
        std::cout << "color and fruit are not equal\n";
 
    return 0;
}

//enum class情况下
#include <iostream>
int main()
{
    enum class Color // "enum class" defines this as an scoped enumeration instead of a standard enumeration
    {
        RED, // RED is inside the scope of Color
        BLUE
    };
 
    enum class Fruit
    {
        BANANA, // BANANA is inside the scope of Fruit
        APPLE
    };
 
    Color color = Color::RED; // note: RED is not directly accessible any more, we have to use Color::RED
    Fruit fruit = Fruit::BANANA; // note: BANANA is not directly accessible any more, we have to use Fruit::BANANA
    
    if (color == fruit) // compile error here, as the compiler doesn't know how to compare different types Color and Fruit
        std::cout << "color and fruit are equal\n";
    else
        std::cout << "color and fruit are not equal\n";
 
    return 0;
}

//正确使用
#include <iostream>
int main()
{
    enum class Color
    {
        RED,
        BLUE
    };
 
    Color color = Color::RED;
 
    if (color == Color::RED) // this is okay
        std::cout << "The color is red!\n";
    else if (color == Color::BLUE)
        std::cout << "The color is blue!\n";
 
    return 0;
}

Typedef
例子：
typedef double distance_t; // define distance_t as an alias for type double
 
// The following two statements are equivalent:
double howFar;
distance_t howFar;

typedef double distance_t; // define distance_t as an alias for type double

在C++11中：
using distance_t = double;

Struct
例子：
struct Employee
{
    short id;
    int age;
    double wage;
};
Employee joe; // create an Employee struct for Joe
joe.id = 14; // assign a value to member id within struct joe
joe.age = 32; // assign a value to member age within struct joe
joe.wage = 24.15; // assign a value to member wage within struct joe

赋值：
struct Employee
{
    short id;
    int age;
    double wage;
};
 
Employee joe = { 1, 32, 60000.0 }; // joe.id = 1, joe.age = 32, joe.wage = 60000.0
Employee frank = { 2, 28 }; // frank.id = 2, frank.age = 28, frank.wage = 0.0 (default initialization)

Auto
例子：
自动定义对应的类型
auto d = 5.0; // 5.0 is a double literal, so d will be type double
auto i = 1 + 2; // 1 + 2 evaluates to an integer, so i will be type int

int add(int x, int y)
{
    return x + y;
}
 
int main()
{
    auto sum = add(5, 6); // add() returns an int, so sum will be type int
    return 0;
}

The auto keyword can’t be used with function parameters
不能用于函数形参类型的定义，因为编译器无法在编译阶段识别类型。

void mySwap(auto &x, auto &y)
{
    auto z = x;
    x = y;
    y = z;
}
This won’t work, because the compiler can’t infer types for function parameters x and y at compile time.

控制流 Control flow introduction

Halt 

exit()
The exit function takes an integer parameter that is returned to the operating system as an exit code, much like the return value of main().
像主程序返回值一样，可以给操作系统返回值，从而终止程序。
例子：
#include <cstdlib> // needed for exit()
#include <iostream>
 
int main()
{
    std::cout << 1;
    exit(0); // terminate and return 0 to operating system
 
    // The following statements never execute
    std::cout << 2;
    return 0;
}

if else
switch case
goto
while
do while
for
break continue

sizeof()使用
int _tmain(int argc, _TCHAR* argv[])
{
    int score[] = {50,60,70,20};
    const int len = sizeof(score) / sizeof(score[0]);
    cout<<len<<endl;
    return 0;
}
输出：4

int _tmain(int argc, _TCHAR* argv[])
{
    int score[5] = {50,60,70,20};
    const int len = sizeof(score) / sizeof(score[0]);
    cout<<len<<endl;
    return 0;
}
输出：5

swap(x, y)交换值

std::sort()排序

int array[5] = {30, 50, 20, 10, 40};
std::sort(array, array+5);

c格式的字符串
#include <iostream>
int main()
{
    char name[255]; // declare array large enough to hold 255 characters
    std::cout << "Enter your name: ";
    std::cin.getline(name, 255);
    std::cout << "You entered: " << name << '\n';
 
    return 0;
}

char source[] = "Copy this!";
char dest[50];
strcpy(dest, source);

#define __STDC_WANT_LIB_EXT1__ 1 //不是所有的编译器都支持，需要加这样的定义
char dest[5]; // note that the length of dest is only 4 chars!
strcpy_s(dest, 5, source); // An assert will be thrown in debug mode

strlen()和sizeof()
char name[20] = "Alex"; // only use 5 characters (4 letters + null terminator)
std::cout << name << " has " << strlen(name) << " letters.\n";
std::cout << name << " has " << sizeof(name) << " characters in the array.\n";
输出：
Alex has 4 letters.
Alex has 20 characters in the array.

strcmp() -- Compare two strings (returns 0 if equal)
strncmp() -- Compare two strings up to a specific number of characters (returns 0 if equal)

指针的使用：
int value = 5;
int *ptr = &value; // initialize ptr with address of variable value

int value = 5;
std::cout << &value; // prints address of value
std::cout << value; // prints contents of value
 
int *ptr = &value; // ptr points to value
std::cout << ptr; // prints address held in ptr, which is &value
std::cout << *ptr; // dereference ptr (get the value that ptr is pointing to)
输出：
0012FF7C
5
0012FF7C
5