Язык программирования C++

Размещено на http://www.allbest.ru/

Язык C++ включает все операторы C и добавляет несколько новых операторов. Все операторы имеют приоритет. В таблице ниже приведены операторы в соответствии с приоритетами.

::

[ ]

( )

.

->

++

--

new

delete

delete[ ]

++

--

*

&

+

-

!

~

sizeof

sizeof ( )

typeid( )

(type)

const_cast

dynamic_cast

reinterpret_cast

static_cast

.*

->*

*

/

%

+

-

<<

>>

<

>

<=

>=

==

!=

&

^

|

&&

||

e1?e2:e3

=

*=

/=

%=

+=

-=

<<=

>>=

&=

^=

Под литерами понимаются константы, которые могут содержать данные следующих типов.

· целое число

· символ

· число с плавающей точкой

· строка символов

Константы целые числа являются постоянными элементами данных, которые не имеют дробной части или показателя. Они всегда начинаются с цифры. Можно определять константы в

· десятичном форме

· восметричной форме

· шестнацетиричной форме

Они могут быть со знаком или без и иметь разный тип. Итак.

Десятичная константа начинается с любой ненулевой цифры, то есть 1 2 3 4 5 6 7 8 9 и состоит из любых других цифр 0 1 2 3 4 5 6 7 8 9

Восмеричная константа начинается с 0 и может состоять из любых цифр 0 1 2 3 4 5 6 7.

Шестнадцатеричная константа начинается с 0x и может состоять из следующих цифр и букв 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F.

Для обозначения типа констант применяются суффиксы:

u U - беззнаковое

l L - длинное

i64 - целое 64 бита

Давайте посмотрим пример:

int x=234;

int x1=0234;

int x2=099;

Первое определение это десятичная цифра. Второе восмеричная цифра, а вот третье определение ошибочно и компилятор даст сообщение типа:

D:\Project\2\2.cpp(14) : error C2041: illegal digit '9' for base '8'

D:\Project\2\2.cpp(14) : error C2041: illegal digit '9' for base '8'

При определении шестнадцатеричных констант регистр символов не имеет значения. Эти константы совершенно одинаковые.

int x1=0xFFF;

int x2=0Xfff;

Модификаторы позволяют определять числа со знаком или без, а так же размер числа. Модификатор добавляется в конец. Можно использовать сразу несколько модификаторов.

unsigned x = 328u;// без знака

unsigned x1 = 328ul;// длинное целове без знака

Символьные константы определяются в тексте путем заключения их в кавычки '. Есть три типа констант.

· нормальные символы

· многосимвольные константы

· широкие символы

Вот посмотрите как каждый их типов объявляется:

char a='a';

int b = 'ab';

wchar_t c = L'ab';

Обратите внимание на то, что b имеет тип int. Именно это позволяет использовать два байта для константы. Широкая константа имеет ширину 4 байта. Все остальное будет игнорироваться. При описании константы можно использовать специальные управляющие символы после косой черты.

программирование язык символ реестр константа

Название	Сокрашенное название	ASCII последовательность	Управляющая
Конец Строки	NL (LF)	10 или 0x0a	\n
Горизонтальная таб.	HT	9	\t
Вертикальная таб.	VT	11 или 0x0b	\v
Возврат	BS	8	\b
Перевод Строки	CR	13 или 0x0d	\r
Прогон	FF	12 или 0x0c	\f
Сигнал	BEL	7	\a
Обратная Косая Черта	\	92 или 0x5c	\\
Знак Вопроса	?	63 или 0x3f	\?
Одинарный апостроф	'	39 или 0x27	\'
Двойной опостроф	"	34 или 0x22	\"
Восьмиричное число	ooo	-	\ooo
Шестнадцатеричное число	hhh	-	\xhhh
Недействительный символ	NUL	0	\0

Вот примеры использования:

char a='\n';

char c='\235';

Символы можно задавать числами в десятичной, восмеричной, шестнадцатеричной форме:

char a='\235';

char b='\023';

char c='\x23';

Под числами с плавающей точкой понимаются числа, которые имеют дробную часть. Дробная часть отделяется от основания либо точкой ".", либо знаком "e" (мантисса). Этот знак можно писать в двух вариантах.

e

E

То есть он не зависит от регистра. Числа и спепень могут иметь знак один из:

+

-

Пример объявления подобных констант:

18.46

38.

18.46e0 // 18.46

18.46e1 // 184.6

Так же при определении константы можно использовать два суффикса:

F- float

L - long double

Строки - это тип данных, который состоит от 0 до нескольких символов. Для определения строк их заключают в двойные кавычки ". Общий вид строки такой.

"набор символов"

Обычно строка определяется так:

char имя[количество символов]

Давайте посмотрим примеры. Длина строки может быть не определена заранее:

char *szStr = "1234";

szStr[2] = 'A';

Компилятор VC умеет собирать одинаковые строки вместе, что позволяет оптимизировать размер выходного файла. Для разрешения подобного рода операций есть опция компилятора /Gf.

При определении строк смежные строки объединяются. Смотрите, это одна и таже строка.

char szStr[] = "12" "34";

char szStr1[] = "1234";

Данное свойство может помочь при выводе длинных строк:

cout << "Hello"

"Step by Step"

"Site" << endl;

Это сработает и скомпилируется. Есть другой метод объединения строк.

cout << "Hello\

Step by Step \

Site" << endl;

Попробуйте, Вы будете немного удивлены так как данные надписи выведутся через довольно большой интервал. То есть будут учитываться пробелы.

В реализации VC есть ограничение на длинну строки. Она не может быть больше 2,048 байтов. Определяя размер строки вы должны учитывать, что последний символ строки должен быть \0. То есть длину строки надо давать на один больше.

В строке могут быть использованы управляющие символы, которые указаны при описании символов. Вот так например.

cout << "Hello\n\tStep by Step\nSite\n" << endl;

Давате я приведу Вам английскую терминологию. Объявление говорит компилятору, что такое имя или программный элемент существует. Определение описывает данное имя. Любое имя для использования должно быть объявлено.

Вводят одно или больше имен в программу. Объявление служит одновременно и определением за исключением случаев:

· прототип функции

· объявление статического элемента данных в декларации класса

· используется extern

· объявления имени класса без определения (например, class my;)

· используется typedef

Пример объявлений и определений:

int i;

int j = 10;

class CheckBox : public Control

{

public:

Boolean IsChecked();

virtual int ChangeState() = 0;

};

Просто объявление:

extern int i;

char *strchr( const char *Str, const char Target );

Определение - уникальная спецификация объекта или переменной, функции, класса или списка. Поскольку определения должны быть уникальными, программа может содержать только одно определение для данного программного элемента.

Программа состоит из одного или более модулей или, можно так сказать, объектов компиляции, которые в последствии собираются в общий модуль EXE. Каждый отдельный объект компиляции обычно CPP файл, который в результате обработки превращается в OBJ файл. Общая схема такова.

CPP _____OBJ_

CPP _____OBJ |-EXE

CPP _____OBJ-

Выполнение начинается с модуля, который имеет функцию main. Каждый модуль имеет свои объявления и определения. Данный раздел посвящен как видны эти элементы между разными объектами компиляции.

Имена объектов и функций имеют понятие связи. То есть определяя функцию или допустим переменную Вы даже того не подозревая устанавливаете связь. То есть связь это просто свойство имени или функции. Это свойство есть всегда не в зависимости от того осознаете вы его наличие или нет. Но лучше осозновать. Итак связей может быть три типа.

Внутренняя

Внешняя

Никакая

Внутреняя связь говорит о доступности этого объекта внутри объекта компиляции и только. То есть он доступен внутри файла CPP, в другом файле объект не виден. Имена с такой связью иногда называют локальными. Объявляются они так:

static int i;

Внешняя связь. При такой связи объект будет доступен в любом файле CPP. То есть он внешний по отношению к отдельным модулям и находится выше их. Объявить объекты с такой связью можно так:

extern int i;

Имена могут быть и без связи, например, объвленные через typedef.

Следующие правила связи относятся к именам (кроме typedef и имен списка). Если имя явно объявлено как static, у него есть внутренняя связь и идентифицирует программный элемент в своем собственном модуле. Списки и typedef имена не имеют связей. Все другие имена имеют внешнюю связь.

Я тут посмотрел MSDN, все так отрывочно и не логично написано.

Там кусочек там кусочек.

Вообщем я попробую всё это обобщить.

Итак, разбираем самый простой пример пустой CPP файл. Белый и пустой как лист бумаги. Что это такое ??? Это область, в которую можно помещать разные элементы. Какие бывают элементы ??? Их всего два типа:

· объявления имен

· определения имен

Весь CPP файл это область определения и релизации. То есть здесь мы можем как определять элементы, так и реализовывать их.

Что можно определять и объвлять. Давайте тоже для простоты сократим список и составим главное

· переменные

· функции

Переменные и функции очень похожи вот главные сходства:

· Имеют имена

· Имеют тип

· Имеют реализацию

· Могут объявлять

Но есть главное отличие. Функции порождают новую подчинёную область реализации и определений, на которую влияет всё более высокие области. Давайте введем функцию main, которая есть в каждой программе.

Как видите из рисунка у нас теперь две области. Одна светло серая область CPP и темнее область main. Область функции main является подчиненной областью к области CPP и поэтому область main имеет доступ ко всему, что находится в области CPP и выше её реализации. Правило такое. Из области реалиции и определения есть доступ ко всему, что находится в более высокой области и Выше её !!!. Выше важно. Проверим ??? Вот код.

int i;

void main()

{

i=5;

}

Этот код компилируется без ошибок. Переменная i определена в более старшей области и выше.

Давайте разбираться дальше. Сколько уровней видимости мы можем создать используя функции ??? Только один !!! Это не значит, что их нельзя больше создать. Можно. Уровень реализации функции в CPP один. Нельзя писать код подобный этому.

int i;

void main()

{

i=5;

void inf()

{

i=7;

}

}

Зато такой можно:

int i;

void main()

{

i=5;

}

void inf()

{

i=7;

}

Внимание не путайте с последовательностью вызова функций !!! Это не одно и тоже. Мы говорим про уровни видимости. Получается глобально, что у нас есть всего две области определений и реализаций.

СPP файл

Область функции ограниченная { и }

Вот картинка, она поясняет ситуацию:

Уровень вложения функций один. То есть уровень CPP и уровень функций, которые параллельны. Помните я говорил, что объявление должно быть выше ??? Можно это проверить, этот код даст ошибку.

void main()

{

i=5;

}

int i;

void inf()

{

i=7;

}

Переменная i будет видна только в inf и выше. Все, что объявлено выше функций видно везде, остальное в порядке объявления. Как же ведут себя объекты объявленные внутри функций. Всё, что объявленно внутри функций видно только внутри самой функции. Вот этот код тоже ошибочный.

void main()

{

int i;

i=5;

}

void inf()

{

i=7;

}

Нельзя увидеть переменную за пределами области, в которой она объявлена. Только в подчиненых областях. Вывод, что внутри функции можно давать одинаковые имена и они не будут вступать в конфликт. Действия над одной из переменных в одной функции не будет влиять на другую.

void main()

{

int i;

i=5;

}

void inf()

{

int i;

i=7;

}

Если есть необходимость, чтобы каждая функция влияла на одну переменную объявите её на уровне CPP, вот так:

Самое прикольное, что и в этой простой ситуации базар еще не окончен. Лексиконом буду :-). Так вот присмотритесь к коду ниже. Здесь нет ни одной ошибки.

int i;

void main()

{

int i;

i=5;

}

void inf()

{

i=7;

}

По логике рассказанного компилятор должен был заверищать о том, что в данном случае два имени. Ведь в main объявлено имя, которое есть в более высокой области. А нет !!! Все сложнее в нашем варианте с функциями. Логика такая. Если имя объявлено в осласти CPP и не объявлено в функции, то используется более глобальная переменная, если имя объявлено в функции, то локальное. Смотрите на main в данном случае присвоение i=5 не изменит i глобальную. Почему ??? Потому, что имя объявленно в функции. А в inf изменит потому, что имя в функции не объявлено и компилятор использует глобальное имя.

Пора кричать бардак. Мы запутаемся !!! Запутаетесь. Получается, что объяви в функции имя то же самое, что и глобальное на уровне CPP, то про последнее можно забыть ??? А вот нет. Есть такой хитрый ход, который явно меняет уровень видимости. Что выведется в данному случае ???

int i;

void main()

{

int i;

::i=5;

i=10;

cout << ::i;

}

Выведется 5. А вот в этом ???

int i;

void inf();

void main()

{

int i;

inf();

i=10;

cout << ::i;

}

void inf()

{

i=5;

}

То же выведется 5. Почему ??? Так вот этот знак :: говорит о том, что чихать на то, что объявлено в функции и пользоваться уровнем CPP. Кстати обратите внимание на то, что мне пришлось объявить функцию inf это все из-за правила выше. Вот в таком варианте объявлять не надо.

int i;

void inf()

{

i=5;

}

void main()

{

int i;

inf();

i=10;

cout << ::i;

}

Надо сделать вывод, что объявления без реализации созданы, чтобы избежать проблем следования друг за другом. В чем заключается ошибка следования ??? Смотрите.

void a1()

{

a2();

}

void a2()

{

a1();

}

Такой вызов функций не запрещен, но он не возможен, если нельзя сначала определить, а потом реализовать.

Я немного отвлекся для демонстрации подхода к реализации и объявлениям. Ну ладно. Это для пояснения сути проблеммы, так как следование влияет на видимость.

Итак, общие идеи вроде как понятны. На основе одного CPP, переменных и функций. Но это еще не всё. Внутри функций могут быть свои области видимости. Давайте займемся ими позже. А поговорим с вами об заголовочных файлах H и месте их в нашей жизни. Теперь наш проект будет состоять из:

CPPфайл

Hфайл

Ну, во-первых, вы можете создать H файл и включить в проект, но пока вы его не подключите к CPP файлу он не будет обрабатываться. Не верите ??? Создайте такой файл и подключите его в проект:

int x

Проект соберется и даже не пикнет. Для того, чтобы H файл участвовал в проекте его необходимо подключить к CPP, это делается с помощью #include. Вот так:

#include "3.h"

void main()

{

}

Вот теперь ошибка будет найдена. Что происходит при таком подключении. Физически все, что находится в этом файле включается в то место, где стоит #include. В этом файле должны по правилам находиться объявления переменных или функций. Но ни кто не мешает написать там и реализацию. Вот этот код будет работать:

//

//3.h

//

int x;

void print()

{

}

//

// 3.cpp

//

#include "3.h"

void main()

{

}

В чем же глобальный смысл H файла ??? В заголовочном файле Н помещаются все объявления, которые видны на уровне модуля. Старайтесь не помещать там код. Еще раз все, что находится в H файле будет видно во всем CPP файле. Вот, а теперь надо впомнить о том, что каждое имя должно быть объявлено только один раз. Поэтому вот такой код даст ошибку.

//

// 3.cpp

//

#include "3.h"

#include "3.h"

void main()

{

}

Вот мы с Вам разобрали связку H и CPP. Вобщем пока просто.

Внутри функций код может породить много областей видимости. Каждая пара {} порождает свою область видимости. Давайте посмотрим на код.

#include "stdafx.h"

#include "iostream.h"

void print();

void main(int argc, char* argv[])

{

print();

}

void print()

{

int i=5;

cout << i << endl;

{

int i=6;

cout << i << endl;

}

cout << i << endl;

}

Как Вы думаете, что появится в результате работы этой программы ???

5 6 5

То есть объявление переменной внутри {} c тем же именем и манипуляции с ней не повлияли на переменную более глобального уровня. Кстати {} могут появиться просто так в следствии вашей доброй воли, Фигурные скобки являются обязательными в операторах типа

for

while

swith

и т.д.

И Опять если локальную переменную не объявить, то будет использована переменная из более глобальной области. В этом примере выведутся одни пятерки.

void print()

{

int i=5;

cout << i << endl;

{

cout << i << endl;

}

cout << i << endl;

}

Самое главное отличие в том, что внутри функций количество вложений блоков не ограничено и как следствия областей определения - реализации. Вот так например :-)

void print()

{

{

{

}

{

{

}

}

}

}

Так, что внутри функций с областями видимости и определением переменных надо быть внимательными. Вы как можете изменить более глобальную переменную, так и потерять данные.

Итак, понятие UNC появилось вместе с появлением сети и служит для упорядочивания правил формирования имен в сетях. При этом в сеть могут входить домены как NT, так и Warp Connect, IBM LAN Server, рабочие группы Microsoft, серверы NetWare. Так вот все это будет подчиняться правилам UNC на уровне обращения к серверу, но не дискам. Полную поддержку UNC имеет только для сетей на основе Microsoft NT Server. И здесь есть тонкость. Вы можете по UNC обратиться к сетевому ресурсу даже если его не видно в сетевом окружении. То есть зная имя машины и каталога всегда можно обратиться к данной машине. Это важно при создании своих приложений, которые будут работать в сети.

При этом не надо забывать, что при работе в сети файловая система не влияет на приложения. Например, никто не запрещает из скажем NT обратиться к сетевому диску FAT 32, хотя NT само не умеет работать с FAT 32. Это очень хороший признак для программиста, хоть об этом думать не надо.

Задаются имена UNC по правилам:

\\<имя сервера>\<имя каталога>

Например

\\ServerEnterprize\Finanse\

или

\\ServerEnterprize\Finanse\1998.xls

Для работы с именами UNC есть ряд функций в Shell Utility APIs. Например, функция PathIsUNCServer проверяет правильность имени UNC. Для примера вот она какая:

BOOL PathIsUNCServer

(

LPCTSTR pszPath

);

Многие встроеные функции Windows, например, CreateDirectory работают с UNC именами.

Итак, для первого уровня создания программ на уровне файл сервера есть возможность использовать UNC имена, которые имеют свои функции для работы и поддерживаются большинством файловых операций Windows. Так что у Вас есть возможность помещать на сетевой диск настроечные файлы, формы и так далее и в последствии использовать их в своей программе на локальной станции. Результат все это надо править только один раз и изменения будут на всех станциях.

Ранее в MS DOS для имен файлов существовало всем не безызвестное правило 8.3. В операционных системах Windows 9x, NT 4.0 есть возможность импользовать длинные имена файлов. Реализация длинных имен строится на основе FAT (File Allocation Table). В MS DOS для иинформации о файле используется одна запись. Для реализации длинных имен и совместимости с MS DOS для длинных имен файлов используется несколько записей в этой таблице. Только этим записям присваиваются следующие атрибуты.

Только чтение

Системный

Скрытый

Метка тома

При таком наборе атрибутов данные записи не видит ни одна программа как и сама MS DOS, зато хорошо различает Windows вот на этом трюке и основана совместимость с ранними версиями операционных систем. И тут возникает интересная ситуация. Для программиста в Windows все равно. Функция типа

CreateDirectory

DeleteFile

CreateFile

OpenFile

......

Уже умеют работать с длинными именами и заботы мало. Даже старые программы для MS DOS могут работать с файлами, у которых длинные имена до тех пор пока их не:

Переименуют

Переместят

Есть функции, которые умеют преобразовывать файлы в короткие и по коротким получать длинные. Например GetLongPathName или GetShortPathName. Вот пример кода:

#include "stdafx.h"

#include "afx.h"

#include "iostream.h"

int main(int argc, char* argv[])

{

DWORD dwResult;

char s[256];

char buffer[256];

lstrcpy(s,"c:\\mycatalog code.txt");

dwResult=GetShortPathName(s ,buffer,256);

if (!dwResult) cout << "Error ";

else cout << buffer<< endl;

return 0;

}

А вот результат:

c:\MYCATA~1.TXT

Press any key to continue

Обратите внимание файл c:\\mycatalog code.txt должен обязательно существовать на диске, иначе у функции будет ошибка выполнения. Дело в том, что короткое имя получаемое в данном случае готовится по определенным правилам и в этих правилах сказано, что имя зависит от других коротких имен.

Давайте посмотрим правила формирования коротких имен.

1. Все буквы становяться большими

2. Имя - первые 6 букв, а остальное отрезается.

3. Хвост - "~цифра", если такое имя уже есть, то цифра будет увеличиваться.

4. Если доходим до 9, то уменьшаем количество букв и хвостик из двух знаков.

5. Расширение - первые 3 буквы, а остальное отрезается

URL - это уникальный адрес ресурса в сети Internet. Сразу скажу какое это имеет отношение к VC. Библиотека MFC поддерживает ряд классов для работы с интернет и соответственно использует это понятие, кроме того есть понятие Internet Api включающие функции по работе с Интернет. URL адрес выглядит так:

http:://www.firststeps.ru/mfc/index.html

______________________________________

http://- метод доступа, например может быть и другой скажем ftp.

www- имя хост компьютера

firststeps- имя субдомена

ru- имя домена

/mfc/index.html- имя ресурса

Вот пример кода использующий URL:

HINTERNET hURL;

HINTERNET hInternetSession;

hURL = InternetOpenUrl( hInternetSession,

"http:://www.firststeps.ru/",

NULL, 0, 0, 0);

Используется URL и в HTMLHelp API новом виде справочной системы используемой в Windows 98. Так как этот вид справочной системы организован на основе HTML, то понятие URL становиться основопологающим. Вот в функции вызова HtmlHelp в параметре pszFile может быть либо имя файла, либо URL.

HWND HtmlHelp(HWND hwndCaller, LPCSTR pszFile, UINT uCommand, DWORD dwData);

ShellExecute позволяет вызывать страницы по URL адресу.

ShellExecute(NULL, "open", "http:://www.firststeps.ru/",

NULL, NULL, SW_SHOWNORMAL);

FAT32 представляет из себя расширение файловой системы FAT. С чем связано появление этой файловой системы ??? Со старыми проблемами связанными с разделами диска больше 512 MB. FAT не умеет создавать разделы больше данного значения. Раньше для этого использовались, например, специальные программы типа Disk Manager. Начиная с OSR2 при создании разделов с использованием FDisk у Вас есть возможность подключить опцию больших дисков. Если Вы сделаете так, то все ваши разделы больше лимита будут FAT32.

Выгодность использования FAT32 заключаеться в том, что размер блока всего 4 KB вместо 16 KB в FAT. Естественно это сказывается на том, что при делении файла на размер кластера получаеться остаток, который занимает весь кластер даже если в нем 1 байт. Вообщем место надо меньше для хранения файлов. Кроме того максимальный размер у FAT32 - 2 Тб вместо 2 Гб. Вообще все хорошо кроме того, что данную файловую систему не может читать напрямую NT и старые версии. А вот по сети все будет нормально. То есть если сделать диск сетевым, то все клинты сети смогут с ним работать.

Вобщем-то все эти мелочи нам как программистам зачастую не нужны, если мы не собираемся производить совсем низкоуровневые операции с диском. Я говорю совсем вот почему. Абсолютное чтение сектора с диска это в принципе операция низкого уровня. Но функция, которая это умеет делать

Int 21h Function 7305h

Ext_ABSDiskReadWrite

Умеет читать данные с:

FAT32

FAT16

FAT12

Как видите уровень обращения к диску должен быть еще ниже. Так же обратиться к секторам на диске можно используя DeviceIoControl. Эта функция посылает управляющие команды непосредственно устройству. Через нее тоже можно проводить низкоуровневые операции. Так вот, читая сектора вам придется выделять буфер для данных, а это требует как минимум знания размера читаемого участка.

WNet - это группа функций, которая позволяет Вам программным путем манипулировать сетевыми ресурсами. Когда Вы устанавливаете разрешения на сетевой доступ к каталогу или диску, просматриваете список сетевых ресурсов - это все делает WNet. Диалоговое коно которое Вам должно быть известно при подключении сетевого диска есть как раз одна из функций WNet. Поддерживаеться данная возможность как в Win 95 так и в Win NT. Можно расматривать WNet как интерфейс доступа к удаленным файлам.

Код вызова этого диалога изумительно просто.

// testWNet.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "afxwin.h"

#include "winnetwk.h"

void main()

{

WNetConnectionDialog(NULL,RESOURCETYPE_DISK);

}

Для объявления функций Вам нужно подключить заголовочный файл winnetwk.h и библиотеку MPR.LIB. Это гарантирует Вам работу с функциями WNet. Давайте посмотрим какие вообще функции есть:

· WNetAddConnection - Связь устройства с сетевым ресурсом

· WNetAddConnection2 - Связь устройства с сетевым ресурсом

· WNetAddConnection3 - Связь устройства с сетевым ресурсом

· WNetCancelConnection - Разрыв связи с сетевым устройством

· WNetCancelConnection2 - Разрыв связи с сетевым устройством

· WNetConnectionDialog - Вызов диалогового окна сетевого соединения

· WNetConnectionDialog1 - Вызов диалогового окна сетевого соединения

· WNetDisconnectDialog - Вызов диалогового окна разрывыа соединения

· WNetDisconnectDialog1 - Вызов диалогового окна разрывыа соединения

· WNetGetConnection - Получение сетевого имени ресурса

· WNetGetUniversalName - Получение сетевого имени ресурса

· WNetCloseEnum - Начинает перечислять сетевые ресурсы

· WNetEnumResource - Продолжает перечислять сетевые ресурсы

· WNetOpenEnum - Заканчивает пересилять сетевые ресурсы

· WNetGetUser - Получает имя пользователя в сети

· WNetGetNetworkInformation - Получаем расширеную инфоормацию о сети

· WNetGetLastError - Получаем последнею ошибку

· WNetGetProviderName - Получаем информацию о поставшике ресурса

· WNetGetResourceInformation - Получаем информацию о ресурсе

· WNetGetResourceParent - Определяет родителя поставщика ресурса в сети

Эти два набора API появились в следствие развития операционной системы Windows и отражают переход от 16 разрядной операционной системы к 32 разрядной.

Windows 3.1 16 разрядов Win16 API

Windows 95 32 разряда Win 32 API

Если представить полную картину, то WIN API в количестве модификаций больше. Нельзя говорить о полной совместимости WIN32 API для WIN 95, WIN NT и 32 разрядного расширения WINDOWS 3.1 32s. Я бы сказал, что существуют три 32 разрядных API очень близких, но имеющих некоторые различия. Ну например, я сталкивался с проблемой, что один и тот же код работает в WIN95 и не работает в NT и связано это с тем, что для NT обязательно надо обнулить структуру для данной операции.

Естественно, что есть отличия Win16 и Win32. Давайте посмотрим.

Типы данных при переходе к 32 разрядам типы данных естественно меняются. Например, тип INT становится 32 разрядным. То есть имеет длину 32 бита.

NEAR и FAR типы указателей. Они теперь не нужны, так как память линейная и любой указатель может добраться до любой ячейки памяти.

Вызов API функций. Их вызовы тоже изменились. Когда Вы пользуетесь каркасной библиотекой типа MFC или OWL это не всегда заметно, так как различия максимально скрываются при программировании на чистом C это видно. Например, ко многим функциям прибавлено расширение Ext, которое говорит о том, что вызывается функций WIN 32, так как для совместимости со старыми приложениями необходимо оставить вызов фунции как он был для 16 разрядов. Вот пример.

WIN16WIN32

ScaleWindowExt ScaleWindowExtEx

SetBitmapDimension SetBitmapDimensionEx

Одновременно в связи с новыми возможностями операционной системы была реализована поддержка потоковой многозадачности, созданы новые элементы интерфейса.

Следствием перехода на 32 разпрядный код явилось то, что не стало возможно легко совмещать код 16 и 32. Ну и что скажете Вы ? Будем писать только на 32. Так-то оно так, только компьютеризация началась не вчера и до нас было написано много, в том числе и под Win16 всяких DLL. И наверно, часть из них уже без исходного кода. Что прикажите делать ??? Этим вопросом естественно заинтересовались и в Microsoft, наверно потому, что сами его и создали :-))))

Давайте внимательнее посмотрим на различия в адресации. Адрес в Win32 формируется как 0:32, то есть есть только смещение, в то время как в Win16 адрес формируется как 16:16, то есть сегмент:смещение. Механизм преобразования адресов должен быть по факту.

При передаче данных существует проблема с округлением и восстановлением INT. Но и это не все, так как данные могут возвращаться через стек и стек должен быть корректно очищен. Хотя дело еще хуже, так как 16 разрядный код для этого пользуется регистрами SS:SP, в то время как 32 регистрами SS:ESP. Ну даже так вкратце понятно, что вопрос не тривиальный. Так как решать его надо было, то выработали метод, который называется thunk. Этот механизм используется для каждого вызова кода разной разрядности. Для данного вида работ был выпущен thunk компилятор.

Ну, давайте делайте выводы. WIN API для разных платформ не является совершенно одинаковым. Второе, что никто не запрещает использовать DLL 16 bit в приложениях 32.

WSH - это язык скриптов, который может поддерживать VBScript без броузера, что позволяет Вам создавать различные сценарии и приложения. Вообщем можно сказать, что данный вид сценариев является более интелектуальной заменой BAT файлов.

Что представляет из себя этот сценарий ??? Это обычный текстовый файл с расширением VBS. Его можно создать прямо в NotePad. Внутри должен быть корректный код VBSсript. Если у Вас все есть для WSH, то значек с расширением VBS будет таким:

Что написать, чтобы попробовать ??? Ну вот такой простой код.

MsgBox "Hello"

В результате появится диалоговое окно просто с рабочего стола. Кроме VBScript сценарии можно строить на таких языкак как:

JScript

Active Perl

Python

Конечно просто сценарием много не сделаешь, но в сценариях реализована поддержка COM объектов. Часть из них можно сразу использовать. Вот те, которые поставляются стандартно.

Wscript

WshShell

WshNetwork

FileSystemObject

Давайте посмотрим самый простой пример как получить версию самого WSH.

MsgBox WScript.Version

Идея появления WOSA была связана с первым использованием ODBC как стандартного интерфейса доступа к базам данных. Впоследствии идея стандартных интерфейсов была развита дальше, что вылилось в появление понятия WOSA, которая на данный момент включает большое количество интерфейсов.

Общие сервисы:

· ODBC - доступ к базам данных

· Message API - пересылка сообщений

· Telephone API - доступ по телефонной линии

· ADSI - интерфейс распределенных каталогов

· License Service API - интерфейс лицензирования программного обеспечения

Связь:

· SNA API - интерфейс связи хостов

· Sockets API - интерфейс связи на основ протокола TCP/IP

· Remote Procedure Call - интерфейс удаленного вызова процедур

Расширения:

· WOSA/XRT - интерфейс обработки биржевых операций

· WOSA/XFS - интерфейс для банковских операций

Это набор интерфейсов, с помощью которых можно управлять любыми данными в любой точке мира как в глобальных так и локальных сетях. Идеологию WOSA легче понять если представить, что между клиентом и сервисом находится некоторый промежуточный слой или менеджер, который реализует стандартный доступ независимый от самого сервиса.

Клиент - Стандартный интерфейс - сервис - данные

В этой цепочке сервис и данные могут быть какие угодно, а вот интерфейс не должен зависеть от них. Сервис реализует конкретный разработчик, который хочет обеспечить доступ к его данным. На примере ODBC драйвер базы данных реализует сама фирма разработчик стандарта, например Borland для Paradox, для вас же как для разработчика это без разницы. Вы работаете примерно одинаково, что с Paradox, что MS SQL Server, что с Oracle. В набор интерфейсов, чтобы их можно было назвать WOSA должны входить:

· Прикладной программный интерфейс (API);

· Интерфейс с сервером (SPI);

· Менеджер группы приложений/сервисов;

· Базу данных для регистрации приложений и сервисов.

Понятие "пространство имен" появилось вместе с появлением Windows 95 и остается в новых версиях до сих пор. Это иерархическая структура построенная на основе модели COM, которая включает:

· Диски для хранения информации

· Принтеры

· Сетевые ресурсы

· Дополнительные компоненты

Строится эта модель на основе COM, как и было объявленно при появлении этого интерфейса, что в будущем файловая система будет строиться на принципах COM (Освой программирование OLE за 21 день). Пространство имен вы видите используя Exploler. Вот это и есть пространство имен. То что вы видите отличается от файловой системы как таковой и это важно. Это не одно и тоже хотя похоже.

Самым верхнем уровнем иерархии считается рабочий стол. На данный момент пространство имен содержит больше объектов, чем файловая структура. Первое понятие это папка Shell folder. Это объект, который владеет другими объектами. Папка - это аналог директории, при этом многие объекты таковыми и являются. Подчеркиваю многие, но не все. Вот, например, те которые не имеют аналогов каталогов и являются виртуальными папками, например, My Computer или Network Neighborhood. Данные о папках, которые имеют аналоги на файловой системе хранятся в реестре по пути. Обратите внимание, что они хранятся в разделе HKEY_CURRENT_USER и специфичны для каждого пользователя.

HKEY_CURRENT_USER/Software/Microsoft/Windows/CurrentVersion/Explorer/Shell Folders/

Каждый объект в данной иерархии имеет свой уникальный номер (идентификатор), который и определяет положение этого объекта. При создании приложений Вы манипулируете понятием указателя на элемент списка - Pointer to an Identifier List (PIDL).

В ваших программах для поддержки работы с пространством имен необходимо подключить описание функций и констант.

#include <shlobj.h>

Весь список возможностей включает интерфейсы к объектам, которые естественно имеют свои функции:

ICommDlgBrowser

IDockingWindow

IDockingWindowFrame

IDockingWindowSite

IEnumIDList

IPersistFolder

IShellBrowser

IShellExecuteHook

IShellFolder

IShellIcon

IShellView

Функции:

BrowseCallbackProc

SHAddToRecentDocs

SHBrowseForFolder

SHChangeNotify

SHFileOperation

SHFreeNameMappings

SHGetDataFromIDList

SHGetDesktopFolder

SHGetFileInfo

SHGetInstanceExplorer

SHGetMalloc

SHGetPathFromIDList

SHGetSpecialFolderLocation

SHLoadInProc

Для облегчения доступа к наиболее часто используемым папкам предусмотрены ряд констант и функции SHGetSpecialFolderLocation, которые описаны в подробностях.

Структуры:

BROWSEINFO

CIDA

FOLDERSETTINGS

SHFILEINFO

SHFILEOPSTRUCT

SHNAMEMAPPING

STRRET

Перечисления:

SHCONTF

SHGNO

Операционная система Windows использует файлы с расширением INF. Это обычный текстовый файл очень похожий по структуре на INI файлы. В Windows он применяется для разных целей:

· Автоматизация инсталяции Windows

· Информация для инсталляции оборудования

· Информация для инсталляции программ

Для программистов конечно важное место занимают последние два варианта применения. Если Вы пишите драйвер для устройства Windows, то для его установки вам нужен этот файл. Вы, наверно, часто сталкивались с поиском этого файла при установке оборудования. На каждой инсталляционной дискете для драйверов монитора, сетевых карт и так далее присутствует этот файл. Можно запустить этот файл из проводника через всплывающее меню действием "установить" :-)

Второе его применение - возможность создания программ быстрой установки. Для установки программного обеспечения есть большое количество программ типа Setup Wizard. Но все они дописывают около 100 КБ или больше своего кода. Что делать, если это больше чем Ваша утилита вообще, или если Вы предпологаете распространять Вашу программу по интернету ? Вобщем используя INF файл у Вас есть возможность создать самому маленькую утилиту инсталляции. При этом сохранив функциональность и создав рабочую группу или запись в реестре для необходимости. Вот пример, как создается группа.

[DefaultInstall]

.......

UpdateInis = Test.Inis

........

[Test.Inis]

setup.ini, progman.groups,, "group321=Test"

В INF файле можно описать практически все необходимое для инсталляции программы. При этом не надо знать функции API, например, для записи данных в реестр. Вот например как это делается в INF

[DefaultInstall]

......

AddReg = Test.Add.Reg

......

[Test.Add.Reg]

HKLM,%URJ1%,DisplayName,"%Test_Desc%"

......

[Strings]

......

URJ1 = "Software\Microsoft\Windows\CurrentVersion"

APPS_DESC = "Accessories"

Test_Desc = "Test App"

......

Но программа инсталляции все равно нужна. Правда в данном варианте она коротенькая совсем. Естественно она должна называться типа Setup.exe для красоты. Основное это то, что ваша программа инсталляции должна вызывать ShellExecuteEx и ей нужно передать местонахождение Вашего INF файла. При этом нужно дождаться окончания процесса его выполнения, тут поможет WaitForSingleObject.

Описание INF файла требует отдельного разговора, а вот идея его организации такова. Очень часто параметр ссылается на раздел, в котором другие параметры и тем самым моделируется дерево.

[DefaultInstall]

......

AddReg = Test.Add.Reg--------

|

...... |

|

[Test.Add.Reg] <-------------

Кроме того в разделе Strings можно создать константы, которые в последствии использовать в параметрах (%имя_константы%)

[Strings]

APPS_DESC = "Accessories"

Да, если Вы опишите нестандартный раздел или ошибетесь, то он просто игнорируется. Это говорит о том, что для генерации INF файла надо бы использовать или самому написать утилиту :-) Правила INF файлов таковы:

· Имена разделов заключены в квадратные скобки - [ ]

· Имена записей могут быть не уникальны, но порядок их размещения играет роль

· Нестандартные разделы игнорируются

Реестр Windows - это специализированная база данных для хранения информации о работе и настройке Windows. Реестр пришел на замену INI файлов Windows 3.1. Тогда каждая программа для сохранения информации создавала свой INI файл. Теперь все это хранится вместе. Для обеспечения структуризованности информации реестр сделан в виде дерева. Осознаете Вы или нет, но настраивая Windows, например монитор или музыкальную карту вы вносите изменения в реестр, хоть и этот процесс скрыт от Вас. Можно сказать, что "Панель Управления" является интерфейсом к реестру. Так как графический интерфейс обеспечивает далеко не все возможности по настройке реестра в поставку Windows входит специальная утилита RegEdit для редактирования реестра вручную. Ее можно запустить через меню "Пуск" и "Выполнить", при этом в строке запуска наберите regedit.

Реестр имеет определенную структуру. Весь реестр делится на крупные разделы:

· HKEY_CLASSES_ROOT - В этом разделе хранится информация необходимая для поддержки системой OLE и данные о основных настройках пользовательского интерфейса.

· HKEY_CURRENT_USER - Здесь хранятся настройки персонального пользователя, который в данный момент работает на компьютере.

· HKEY_LOCAL_MACHINE - Здесь хранится информация специфичная для данного компьютера, т.е. сведения об оборудовании и его конфигурации, параметры программ и так далее.

· HKEY_USERS - Здесь хранится информация о всех пользователях зарегистрированных на компьютере, так же здесь хранятся параметры доступные всем.

· HKEY_CURRENT_CONFIG - Здесь хранятся текущие данные о текущих настройках устройств.

· HKEY_DYN_DATA - Здесь динамические данные о состоянии различных устройств.

Как вы видите некоторые разделы повторяются или являются частью других и это не просто так в этом есть логика. Сначала надо определиться, что на компьютере может быть несколько конфигураций как пользователей так и оборудования. Так же надо хранить общие данные для всех. Тогда при работе программного обеспечения надо всегда смотреть какой пользователь и какой профиль оборудования. Это не удобно. На компьютере в текущий момент только один профиль пользователя и профиль оборудования, поэтому проще обращаться к нему. Вот для этого и данные о конфинурации конкретного пользователя и оборудования вынесены в отдельный раздел, чтобы к нему сразу можно было обратиться не узнавая какой пользователь сейчас ! Если эта мысль понятна, то и понятно деление на разделы и повторения в реестре. Вот я попробую сделать рисунок поясняющий эту мысль:

При старте компьютера Вас спрашивают имя для того, чтобы знать каким профилем пользоваться и в момент старта Windows копирует соответствующую ветвь из HKEY_USERS в HKEY_CURRENT_USER, а при выходе из Windows обратно копируется. Кстати создать пользователей можно в "Панель управления" - "Пользователи".

Ну это понятно, а что же для программиста ??? В Windows API есть ряд функций для работы с реестром. Вот они. Часть из них описана в "Подробности - Функции для работы с реестром".

RegCloseKey

RegConnectRegistry

RegCreateKey

RegCreateKeyEx

RegDeleteKey

RegDeleteValue

RegEnumKey

RegEnumKeyEx

RegEnumValue

RegFlushKey

RegGetKeySecurity

RegLoadKey

RegNotifyChangeKeyValue

RegOpenKey

RegOpenKeyEx

RegQueryInfoKey

RegQueryMultipleValues

RegQueryValue

RegQueryValueEx

RegReplaceKey

RegRestoreKey

RegSaveKey

RegSetKeySecurity

RegSetValue

RegSetValueEx

RegUnLoadKey

GetPrivateProfileInt

GetPrivateProfileSection

GetPrivateProfileSectionNames

GetPrivateProfileString

GetPrivateProfileStruct

GetProfileInt

GetProfileSection

GetProfileString

WritePrivateProfileSection

WritePrivateProfileString

WritePrivateProfileStruct

WriteProfileSection

WriteProfileString

В MFC есть ряд своих возможностей работы с реестром. Во-первых, класс CWinApp умеет работать с реестром (смотрите "Шаг 39 - Работа с реестром").

Во-вторых есть класс CRegKey, который тоже дает возможность работы с реестром (смотрите "Шаг 213 - Работа с реестром CRegKey").

Размещено на Allbest.ru